9 - Reproducing GPT-2/9 - Reproducing_GPT-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reproducing GPT-2 From Scratch\n",
    "\n",
    "[Video](https://www.youtube.com/watch?v=l8pRSuU81PU)<br>\n",
    "[Build-NanoGPT Repository](https://github.com/karpathy/build-nanogpt)<br>\n",
    "[NanoGPT Repository](https://github.com/karpathy/nanogpt)<br>\n",
    "[Errata](https://github.com/karpathy/build-nanogpt?tab=readme-ov-file#errata)<br>\n",
    "[Discussions](https://github.com/karpathy/build-nanogpt/discussions)<br>\n",
    "[Eureka Labs Discord](https://discord.com/invite/3zy8kqD9Cp)\n",
    "\n",
    "## Table of Contents\n",
    "\n",
    "- [GPT-2 Architecture Overview](#gpt-2-architecture-overview)\n",
    "  - [Is Attention All We Need?](#is-attention-all-we-need)\n",
    "  - [Configuration](#configuration)\n",
    "  - [The GPT Class](#the-gpt-class)\n",
    "  - [The Block Class](#the-block-class)\n",
    "  - [The MLP Class](#the-mlp-class)\n",
    "  - [The CausalSelfAttention Class](#the-causalselfattention-class)\n",
    "  - [Tokenization](#tokenization)\n",
    "- [Resetting the Weights](#resetting-the-weights)\n",
    "- [Creating Tokenized Training Input](#creating-tokenized-training-input)\n",
    "- [Calculating the Loss](#calculating-the-loss)\n",
    "- [Optimization](#optimization)\n",
    "  - [Sanity Check](#sanity-check)\n",
    "  - [Data Loading](#data-loading)\n",
    "- [Bugfixing](#bugfixing)\n",
    "  - [Token Embedding Layer and Linear Output Layer are Identical?!](#token-embedding-layer-and-linear-output-layer-are-identical)\n",
    "  - [Weight initialization](#weight-initialization)\n",
    "- [Optimizing Model Training](#optimizing-model-training)\n",
    "  - [NVIDIA Tensor Cores and TensorFloat32](#nvidia-tensor-cores-and-tensorfloat32)\n",
    "  - [Decreasing Memory Movements](#decreasing-memory-movements)\n",
    "  - [PyTorch Compiling](#pytorch-compiling)\n",
    "  - [FlashAttention and a Caveat of Compilation](#flashattention-and-a-caveat-of-compilation)\n",
    "  - [Removing 'ugly' numbers](#removing-ugly-numbers)\n",
    "  - [Algorithmic Adaptations](#algorithmic-adaptations)\n",
    "    - [Adam/AdamW Optimizer Configuration](#adamadamw-optimizer-configuration)\n",
    "    - [Global Norm Clipping](#global-norm-clipping)\n",
    "    - [Learning Rate Decay](#learning-rate-decay)\n",
    "    - [Dynamic Batch Size Increase](#dynamic-batch-size-increase)\n",
    "    - [Data Loading](#data-loading)\n",
    "    - [Weight Decay and Fused AdamW](#weight-decay-and-fused-adamw)\n",
    "    - [Gradient Accumulation for Simulating Large Batch Sizes](#gradient-accumulation-for-simulating-large-batch-sizes)\n",
    "- [Training on Multiple GPUs](#training-on-multiple-gpus)\n",
    "  - [Introducing DistributedDataParallel](#introducing-distributeddataparallel)\n",
    "  - [Adapting the Gradient Accumulation](#adapting-the-gradient-accumulation)\n",
    "  - [Adapting the DataLoader](#adapting-the-dataloader)\n",
    "  - [Fully Integrating DistributedDataParallel](#fully-integrating-distributeddataparallel)\n",
    "  - [Distributing the Training Loop](#distributing-the-training-loop)\n",
    "- [We Definitely Need More Data](#we-definitely-need-more-data)\n",
    "  - [DataLoader Adjustments](#dataloader-adjustments)\n",
    "- [Eval, Logging and Visualization](#eval-logging-and-visualization)\n",
    "  - [HellaSwag Eval](#hellaswag-eval)\n",
    "  - [Visualizing Training Progress](#visualizing-training-progress)\n",
    "- [Opportunities for Optimization and Enhancement](#opportunities-for-optimization-and-enhancement)\n",
    "\n",
    "<br>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In 2019, OpenAI released version 2 of its General Pretrained Transformer (GPT-2) model.<br>\n",
    "The release consisted of:\n",
    "- a [blog post](https://openai.com/blog/better-language-models/),\n",
    "- a [research paper \\[Radford et al. 2019\\]](https://d4mucfpksywv.cloudfront.net/better-language-models/language_models_are_unsupervised_multitask_learners.pdf), and\n",
    "- a [GitHub repository](https://github.com/openai/gpt-2).\n",
    "\n",
    "Moreover, GPT-2 brought not one, but four models of different sizes:\n",
    "- `124M` (124 million parameters),\n",
    "- `355M` (355 million parameters),\n",
    "- `774M` (774 million parameters), and\n",
    "- `1558M` (1558 million parameters).\n",
    "\n",
    "One of the reasons models like GPT-2 are relased as a set of incrementally larger models is to allow for<br>\n",
    "experiments with the different sized models to compare how their performance differs on different tasks.<br>\n",
    "This can indicate the capacity needed to attain certain skills, and it can hint at<br>\n",
    "the direction in which design improvements could be most effective in the future.\n",
    "\n",
    "In this notebook, we will reproduce the `124M` model.<br>\n",
    "Crazy enough, this model was state-of-the-art in 2019, and you can train it in $\\approx 1$ hour today for $\\approx \\$10$ (if you rent some GPUs).<br>\n",
    "To really get the training part right though, we will not only refer to [\\[Radford et al. 2019\\]](https://d4mucfpksywv.cloudfront.net/better-language-models/language_models_are_unsupervised_multitask_learners.pdf), but also to [\\[Brown et al. 2020\\]](https://arxiv.org/abs/2005.14165), the paper that introduced GPT-3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GPT-2 Architecture Overview\n",
    "\n",
    "The original paper describes the GPT-2 model series as follows:<br>\n",
    "![](./images/gpt2_table_sm.png)<br>\n",
    "Source: [\\[Radford et al. 2019\\]](https://d4mucfpksywv.cloudfront.net/better-language-models/language_models_are_unsupervised_multitask_learners.pdf)\n",
    "\n",
    "Note that the table calls the `124M` model `117M`. OpenAI back then just didn't count the parameters correctly.<br>\n",
    "But, correctly, the table states that the small model has $12$ transformer layers and a hidden size of $768$ units.\n",
    "\n",
    "This means:\n",
    "\n",
    "- The small model has $12$ transformer decoder blocks stacked on top of each other\n",
    "    - Each block individually consists of masked multi-head attention, multi-head attention, feed-forward and normalization layers\n",
    "    - Within each block, residual connections are used around normalized attention layers and feed-forward layers\n",
    "    - Each block's total output is passed to the next block as input\n",
    "- Each transformer block also has $768$ hidden units\n",
    "    - The value $768$ represents the dimensionality of the embeddings within each layer, i.e. the space we map our tokens into to represent their meaning\n",
    "    - $768$ also sets the size of input/output vectors for the self-attention mechanism and feed-forward layers\n",
    "    - In other words, it's the **bandwith of the model across layers**\n",
    "\n",
    "If any of the above is unclear, don't worry about it.<br>\n",
    "See lecture 7 for details.\n",
    "\n",
    "Going from the vanilla transformer architecture, you can start to think of the GPT-2 model looking somewhat (not exactly, we will get to that) like this:<br>\n",
    "![](./images/gpt2_layout_general.png)<br>\n",
    "Source: [dzlab.github.io](https://dzlab.github.io/ml/2020/07/25/gpt3-overview/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The original [GPT-2 repository](https://github.com/openai/gpt-2) released the model in TensorFlow.<br>\n",
    "We will have a look at [HuggingFace's GPT-2 Implementation](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gpt2/modeling_gpt2.py) instead.<br>\n",
    "Somewhat more readable. Somewhat.\n",
    "\n",
    "Let's see how things work in HuggingFace's implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import GPT2LMHeadModel\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transformer.wte.weight torch.Size([50257, 768])\n",
      "transformer.wpe.weight torch.Size([1024, 768])\n",
      "transformer.h.0.ln_1.weight torch.Size([768])\n",
      "transformer.h.0.ln_1.bias torch.Size([768])\n",
      "transformer.h.0.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.0.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.0.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.0.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.0.ln_2.weight torch.Size([768])\n",
      "transformer.h.0.ln_2.bias torch.Size([768])\n",
      "transformer.h.0.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.0.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.0.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.0.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.1.ln_1.weight torch.Size([768])\n",
      "transformer.h.1.ln_1.bias torch.Size([768])\n",
      "transformer.h.1.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.1.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.1.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.1.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.1.ln_2.weight torch.Size([768])\n",
      "transformer.h.1.ln_2.bias torch.Size([768])\n",
      "transformer.h.1.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.1.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.1.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.1.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.2.ln_1.weight torch.Size([768])\n",
      "transformer.h.2.ln_1.bias torch.Size([768])\n",
      "transformer.h.2.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.2.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.2.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.2.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.2.ln_2.weight torch.Size([768])\n",
      "transformer.h.2.ln_2.bias torch.Size([768])\n",
      "transformer.h.2.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.2.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.2.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.2.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.3.ln_1.weight torch.Size([768])\n",
      "transformer.h.3.ln_1.bias torch.Size([768])\n",
      "transformer.h.3.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.3.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.3.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.3.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.3.ln_2.weight torch.Size([768])\n",
      "transformer.h.3.ln_2.bias torch.Size([768])\n",
      "transformer.h.3.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.3.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.3.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.3.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.4.ln_1.weight torch.Size([768])\n",
      "transformer.h.4.ln_1.bias torch.Size([768])\n",
      "transformer.h.4.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.4.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.4.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.4.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.4.ln_2.weight torch.Size([768])\n",
      "transformer.h.4.ln_2.bias torch.Size([768])\n",
      "transformer.h.4.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.4.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.4.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.4.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.5.ln_1.weight torch.Size([768])\n",
      "transformer.h.5.ln_1.bias torch.Size([768])\n",
      "transformer.h.5.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.5.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.5.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.5.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.5.ln_2.weight torch.Size([768])\n",
      "transformer.h.5.ln_2.bias torch.Size([768])\n",
      "transformer.h.5.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.5.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.5.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.5.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.6.ln_1.weight torch.Size([768])\n",
      "transformer.h.6.ln_1.bias torch.Size([768])\n",
      "transformer.h.6.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.6.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.6.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.6.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.6.ln_2.weight torch.Size([768])\n",
      "transformer.h.6.ln_2.bias torch.Size([768])\n",
      "transformer.h.6.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.6.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.6.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.6.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.7.ln_1.weight torch.Size([768])\n",
      "transformer.h.7.ln_1.bias torch.Size([768])\n",
      "transformer.h.7.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.7.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.7.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.7.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.7.ln_2.weight torch.Size([768])\n",
      "transformer.h.7.ln_2.bias torch.Size([768])\n",
      "transformer.h.7.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.7.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.7.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.7.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.8.ln_1.weight torch.Size([768])\n",
      "transformer.h.8.ln_1.bias torch.Size([768])\n",
      "transformer.h.8.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.8.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.8.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.8.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.8.ln_2.weight torch.Size([768])\n",
      "transformer.h.8.ln_2.bias torch.Size([768])\n",
      "transformer.h.8.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.8.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.8.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.8.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.9.ln_1.weight torch.Size([768])\n",
      "transformer.h.9.ln_1.bias torch.Size([768])\n",
      "transformer.h.9.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.9.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.9.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.9.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.9.ln_2.weight torch.Size([768])\n",
      "transformer.h.9.ln_2.bias torch.Size([768])\n",
      "transformer.h.9.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.9.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.9.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.9.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.10.ln_1.weight torch.Size([768])\n",
      "transformer.h.10.ln_1.bias torch.Size([768])\n",
      "transformer.h.10.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.10.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.10.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.10.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.10.ln_2.weight torch.Size([768])\n",
      "transformer.h.10.ln_2.bias torch.Size([768])\n",
      "transformer.h.10.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.10.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.10.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.10.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.11.ln_1.weight torch.Size([768])\n",
      "transformer.h.11.ln_1.bias torch.Size([768])\n",
      "transformer.h.11.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.11.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.11.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.11.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.11.ln_2.weight torch.Size([768])\n",
      "transformer.h.11.ln_2.bias torch.Size([768])\n",
      "transformer.h.11.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.11.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.11.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.11.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.ln_f.weight torch.Size([768])\n",
      "transformer.ln_f.bias torch.Size([768])\n",
      "lm_head.weight torch.Size([50257, 768])\n",
      "\n",
      " tensor([-0.0188, -0.1974,  0.0040,  0.0113,  0.0638, -0.1050,  0.0369, -0.1680,\n",
      "        -0.0491, -0.0565, -0.0025,  0.0135, -0.0042,  0.0151,  0.0166, -0.1381,\n",
      "        -0.0063, -0.0461,  0.0267, -0.2042])\n"
     ]
    }
   ],
   "source": [
    "model_hf = GPT2LMHeadModel.from_pretrained(\"gpt2\") # 124M parameters, for \"gpt2-xl\" the gold model\n",
    "sd_hf = model_hf.state_dict() # Dictionary of the model's weight/bias tensors\n",
    "\n",
    "for identifier, tensor in sd_hf.items():\n",
    "    print(identifier, tensor.shape)\n",
    "\n",
    "# Print some GPT-2 weights\n",
    "print('\\n', sd_hf[\"transformer.wpe.weight\"].view(-1)[:20])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This seems to not really tell us much at first glance.\n",
    "\n",
    "But think of the above output like this:\n",
    "- `wte` is the weight matrix for the *token embeddings*, \n",
    "- `wpe` is the weight matrix for the *positional embeddings*, \n",
    "- `h` is the hidden state. \n",
    "- The rest is transformer blocks.\n",
    "\n",
    "We can therefore say that GPT-2 has a vocabulary size of $50257$ tokens, each being mapped to a representing embedding vector of size $768$.<br>\n",
    "Furthermore, each token can be attended to by $1024$ prior tokens in a sequence. GPT-2's context size is $1024$ tokens.\n",
    "\n",
    "If you don't know what any of that means, don't worry about it, refer to [8 - GPT Tokenizer](../8%20-%20GPT%20Tokenizer/8%20-%20Tokenization.ipynb).\n",
    "\n",
    "Let's actually take a look at the positional embedding matrix by plotting it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(sd_hf[\"transformer.wpe.weight\"], cmap=\"gray\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to learn these positional embeddings because by default, transformers don't process data sequentially.<br>\n",
    "In fact, transformers would have no idea of the concept of sequence (contrary to e.g. RNNs/LSTMs) if we didn't provide them with positional information.<br>\n",
    "\n",
    "To solve this, we encode not only the token meaning itself, but also it's position for the transformer to be able to better take semantics into account.<br>\n",
    "We've plotted the positional embedding matrix informing about the position of each token above.<br>\n",
    "Positional embeddings are learned for the $1024$ context size and across the full $768$ hidden size.<br>\n",
    "The positional embeddings are simply added to the token embedding values to form the input to the transformer.\n",
    "\n",
    "> Somewhat counterintuitively, the positional embeddings are not fixed, but also learned from a random starting setup, just like the token embeddings themselves.<br>\n",
    "\n",
    "During training, it emerges that for every hidden position and across all context entries, a sinusoidal function is encoded.<br>\n",
    "Each encoding is slightly different in the function it represents, because each position corresponds to an characteristic information about the position and is processed by the transformer to recover relative nuances deemed important by encountered patterns.<br>\n",
    "\n",
    "We can say that the encoded sinusoidal functions express relative importance through the parameters in the context size wide embeddings.<br>\n",
    "And, to add to that, [GPT-2's Positional Embedding Matrix encodes a Helix](https://www.lesswrong.com/posts/qvWP3aBDBaqXvPNhS/gpt-2-s-positional-embedding-matrix-is-a-helix).\n",
    "\n",
    "**Why aren't the positional embeddings just hard-coded from the beginning? Isn't learning the order of tokens something we could easily express ourselves directly, making optimization for it a waste of time?**\n",
    "\n",
    "It is possible to hard-code information per each hidden state into a model.<br>\n",
    "This was done e.g. with the original [Transformer model\\[Vaswani et al. (2017)\\]](https://arxiv.org/abs/1706.03762) through hard-coding sinusoidal functions.<br>\n",
    "\n",
    "However, a learning process allows for discovery of useful properties (like those of fixed sinusoidal encodings) from token distributions directly.<br>\n",
    "Scaling with the training set size and quality now, this technique now can inform across positional embeddings with additional nuances beyond the 'rigid' position-relationship embedding as such.\n",
    "\n",
    "**Why sinusoidal functions? Why are these structures used to encode positions and why do their estimates emerge from learning too?**\n",
    "\n",
    "Let's get one thing out of the way here: Each positional embedding is $768$-dimensional. The context size is $1024$, meaning we have $1024$ of these $768$ embeddings.<br>\n",
    "The sinusoidal characteristics emerge not per each position embedding, but across all of them when looking per hidden dimension. I graphed this down below to show that.\n",
    "The sinusoidal functions must therefore be representing something akin to inter-position relationships emerging from intra-position values at that hidden dimension.\n",
    "\n",
    "With that out of the way, sinusoidal functions consist of combinations of sine and cosine waves.<br>\n",
    "The space of possible combinations is infinite, implying that each inter-embedding relationship could be encoded uniquely.<br>\n",
    "That's good, that's what we need here.<br>\n",
    "We could argue that this would also work with randomly initialized embeddings. This notion breaks down quickly, though.<br>\n",
    "See, when we are optimizing our embeddings, we actually start out randomly initialized across all embeddings, but the optimization we perform still has sinusoidal functions emerge across the embeddings.<br>\n",
    "Therefore, these functions must be representing relationships better than random embeddings in some way. But how exactly?\n",
    "\n",
    "First, each sinusoidal function is expressed across the full context size. One sinusoidal function per hidden state means we have $768$ of these.<br>\n",
    "Sinusoidal functions, when learnt, are a result of gradient descent optimization, which itself requires differentiable functions.<br>\n",
    "Optimizations emitted from this process are necessarily continuous, specifically enabling (continuous and differentiable) sinusoidal function estimations to emerge across the embedding space.<br>\n",
    "As sinusoidal functions are continuous, different importances between context positions are expressed as being continuous too.<br>\n",
    "This means is that sinusoidal functions make it easy to compute relative importances between any two positions both local and long-range across the context size.<br>\n",
    "\n",
    "> Sinusoidal functions serve as an emulation of the continuous nature of language and are differentiable as a result of the optimization we perform to attain them, coincidentally enabling the model to very well express relative importances between any two positions smoothly.\n",
    "\n",
    "**I can't wrap my head around the helix thing for GPT-2. What's the deal with that?**\n",
    "\n",
    "We said that across each of the $768$ hidden states in the positional embeddings a sinusoidal function is emulated.<br>\n",
    "Now, if we shift our focus back from looking across positional embeddings to looking per each embedding and we squash each $768$-dimensional embedding into just $3$ dimensions, we can plot the embeddings, and they form a continuous curve that rotates around an axis while moving along it. Each positional embedding has $768$ values, each contributing to a respective sinusoidal function. The positional embeddings thus captures a step in time across multiple functions, one per hidden state. The embedding therefore captures both the continuous nature of - and across - positions in a sequence, with all embeddings together forming the periodicity we expect in positional encodings (periodicity across the sequence, i.e. between the embeddings).\n",
    "\n",
    "Let's now go and plot three individual embedding dimensions (columns):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(sd_hf[\"transformer.wpe.weight\"][0, :], label=\"Embedding Pos. 0\")\n",
    "plt.plot(sd_hf[\"transformer.wpe.weight\"][50, :], label=\"Embedding Pos. 50\")\n",
    "plt.plot(sd_hf[\"transformer.wpe.weight\"][100, :], label=\"Embedding Pos. 100\")\n",
    "plt.legend()\n",
    "plt.title(\"Positional Embeddings\")\n",
    "plt.xlabel(\"Hidden Dimension\")\n",
    "plt.ylabel(\"Weight Value\")\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.plot(sd_hf[\"transformer.wpe.weight\"][:, 150], label=\"Weight Index 150\")\n",
    "plt.plot(sd_hf[\"transformer.wpe.weight\"][:, 200], label=\"Weight Index 200\")\n",
    "plt.plot(sd_hf[\"transformer.wpe.weight\"][:, 250], color=\"green\", label=\"Weight Index 250\")\n",
    "plt.legend()\n",
    "plt.title(\"Positional Hidden Dim Values Across Context\")\n",
    "plt.xlabel(\"Context Position Index\")\n",
    "plt.ylabel(\"Weight Value\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While the second plot's green graph may show some pattern across positions at column $250$, this does not mean that column $250$ encodes a full positional relationship.<br>\n",
    "It's just a partial encoding of the $768$-dimensional function that expresses the positional relationships across all $1024$ embeddings.\n",
    "\n",
    "The exact contribution of the single column in the positional encoding matrix is still vaguely understood at best.<br>\n",
    "It is one instrument in an orchestra of $768$ instruments that together formulate the positional relationships.\n",
    "\n",
    "And yet, interestingly, we can tell from this above second graph that this model is somewhat undertrained.<br>\n",
    "We can say this because we see noise in the graphs themselves. We didn't just yet fully converge to sinusoidal function approximations.<br>\n",
    "\n",
    "The parameters in the attention mechanism look like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(sd_hf[\"transformer.h.1.attn.c_attn.weight\"][:300, :300], cmap=\"gray\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's play for a bit with sampling from HuggingFace's GPT-2 and see how that works:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[{'generated_text': \"Hello, I'm a language model, but what I'm really doing is making a human-readable document. There are other languages, but those are\"},\n",
       " {'generated_text': \"Hello, I'm a language model, not a syntax model. That's why I like it. I've done a lot of programming projects.\\n\"},\n",
       " {'generated_text': \"Hello, I'm a language model, and I'll do it in no time!\\n\\nOne of the things we learned from talking to my friend\"},\n",
       " {'generated_text': \"Hello, I'm a language model, not a command line tool.\\n\\nIf my code is simple enough:\\n\\nif (use (string\"},\n",
       " {'generated_text': \"Hello, I'm a language model, I've been using Language in all my work. Just a small example, let's see a simplified example.\"}]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from transformers import pipeline, set_seed\n",
    "\n",
    "generator = pipeline('text-generation', model='gpt2')\n",
    "set_seed(42)\n",
    "generator(\"Hello, I'm a language model,\", max_length=30, num_return_sequences=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Is Attention All We Need?\n",
    "\n",
    "Yes, pretty much.<br>\n",
    "We will not get around to an in-depth look at the paper that started it all: [\\[Vaswani et al. 2017\\]](https://arxiv.org/abs/1706.03762).<br><br>\n",
    "![](./images/transformer_gpt.png)\n",
    "\n",
    "For GPT-2, we can discard everything outside the red box, i.e. the encoder and its connection into the decoder (through what's called cross-attention). \n",
    "\n",
    "> **GPT-2 is a decoder-only model.**\n",
    "\n",
    "We will perform some slight changes to the default decoder.<br>\n",
    "First, the layer norm is moved before the Masked Multi-Head Attention.<br>\n",
    "While layer Norm is also placed before the Feed Forward Network, another Layer Norm is placed after the final Transformer block.\n",
    "\n",
    "In total, we are aiming for this structure:<br>\n",
    "![](./images/gpt2_layout_shuffle_shapes.png)\n",
    "\n",
    "Ok, let's build this.<br>\n",
    "I'll go through the implementation here class by class and then we puzzle everything together to form a working implementation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Configuration\n",
    "\n",
    "First, we create a dataclass `GPTConfig` that will hold the values by which we configure our GPT model.<br>\n",
    "The data class looks like this:\n",
    "\n",
    "```python\n",
    "@dataclass\n",
    "class GPTConfig:\n",
    "    block_size: int = 1024\n",
    "    vocab_size: int = 50257\n",
    "    n_layer: int = 12\n",
    "    n_head: int = 12\n",
    "    n_embd: int = 768\n",
    "```\n",
    "\n",
    "Here's what the parameters mean:\n",
    "- `block_size`: the length of the sequence we want to process at once (context length)\n",
    "- `vocab_size`: the number of possible input tokens\n",
    "- `n_layer`: the number of transformer blocks stacked on top of each other within the GPT\n",
    "- `n_head`: the number of heads per each multi-head attention mechanism (each has `n_layer` layers)\n",
    "- `n_embd`: the dimension of the embeddings, i.e. the hidden size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The GPT Class\n",
    "\n",
    "The structure of our GPT-2 replication is realized within the `GPT` class:\n",
    "\n",
    "```python\n",
    "class GPT(nn.Module):\n",
    "    def __init__(self, config: GPTConfig):\n",
    "        super(GPT, self).__init__()\n",
    "        self.config = config\n",
    "        \n",
    "        self.transformer = nn.ModuleDict(dict(\n",
    "            # Token Embedding Layer\n",
    "            wte = nn.Embedding(config.vocab_size, config.n_embd),\n",
    "            # Position Embedding Layer\n",
    "            wpe = nn.Embedding(config.block_size, config.n_embd),\n",
    "            # The Actual (12) Transformer blocks\n",
    "            h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]),\n",
    "            # Final layer Norm before the output\n",
    "            ln_f = nn.LayerNorm(config.n_embd),\n",
    "        ))\n",
    "\n",
    "        # The Prediction Head, Linear Layer but without Bias\n",
    "        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)\n",
    "```\n",
    "\n",
    "We later on want to be able to load the weights from the HuggingFace version of GPT-2 into our model.<br>\n",
    "Therefore, we need to build this class to stylistically be as close to the HuggingFace parameter setup as can be.<br>\n",
    "To do just that, we build a Dictionary structure `transformer` that serves as a main container, housing everything but the Prediction Head `lm_head`.<br>\n",
    "The `transformer` setup like this allows for `key:value` indexing like HuggingFace's `transformer.[wpe].weight`.\n",
    "\n",
    "Specifically, we apply:\n",
    "- Token Embedding Layer `wte`, mapping each token to an embedding vector of size `n_embd`,\n",
    "- Position Embedding Layer `wpe`, mapping each position in the context size to an embedding vector of size `n_embd`,\n",
    "- Module List `h` of `n_layer` Transformer Blocks, where we now index into numerically, as in HuggingFace's `transformer.h.[0].ln_1.weight`\n",
    "- Layer Norm `ln_f` after the last Transformer block, before the output, as in HuggingFace's `transformer.ln_f.weight`\n",
    "- Linear Layer `lm_head` as the prediction head, mapping normalized Transformer outputs back to the vocabulary size, as in HuggingFace's `lm_head.weight`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Block Class\n",
    "\n",
    "We've seen that the Transformer Block inside the `GPT` class' `h` consists of Block objects.<br>\n",
    "The `Block` class summarizes the Decoder Transformer block:\n",
    "\n",
    "```python\n",
    "class Block(nn.Module):\n",
    "    def __init__(self, config: GPTConfig):\n",
    "        super(Block, self).__init__()\n",
    "        self.ln_1 = nn.LayerNorm(config.n_embd)\n",
    "        self.attn = CausalSelfAttention(config)\n",
    "        self.ln_2 = nn.LayerNorm(config.n_embd)\n",
    "        self.mlp = MLP(config)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x + self.attn(self.ln_1(x))\n",
    "        x = x + self.mlp(self.ln_2(x))\n",
    "        return x\n",
    "```\n",
    "\n",
    "We perform layer normalization, feed that into the Self-Attention mechanism,<br>\n",
    "feed that into another layer normalization and ultimately through an `MLP`, representing the Feed Forward Network.\n",
    "\n",
    "Notice in the `forward()` how the residual connections aren't normalized here.<br>\n",
    "This is better, The more residuals remain untouched, the less obstructed the gradient flow through them.<br>\n",
    "Note, however, that we are also deviating from original Transformer paper with this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The MLP Class\n",
    "\n",
    "The `MLP` is utilized within the Transformer block to build its Feed Forward network part.\n",
    "\n",
    "```python\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, config: GPTConfig):\n",
    "        super().__init__()\n",
    "        self.c_fc = nn.Linear(config.n_embd, config.n_embd * 4)\n",
    "        self.gelu = nn.GELU(approximate='tanh')\n",
    "        self.c_proj = nn.Linear(config.n_embd * 4, config.n_embd)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.c_fc(x)\n",
    "        x = self.gelu(x)\n",
    "        x = self.c_proj(x)\n",
    "        return x\n",
    "```\n",
    "\n",
    "We connect two Linear layers that together form a hidden layer of size `n_embd * 4`, apply<br>\n",
    "a `GELU` activation function between them and then map the output back to the original embedding size `n_embd`.\n",
    "\n",
    "Just like the original, we use [GELU activation \\[Hendrycks et al. 2016\\]](https://arxiv.org/abs/1606.08415):<br>\n",
    "![](https://pytorch.org/docs/stable/_images/GELU.png)\n",
    "\n",
    "In relation to that, we talked about the dead neuron problem extensively in lecture 4 (Makemore 3).<br>\n",
    "If ReLU-activated neurons hold negative values, these values are mapped flat-out to zero by the ReLU function. The neuron in turn will receive zero gradient, no update.\n",
    "\n",
    "Alternatively, GeLU always contributes at least an ever so slight gradient, thereby not abruptly hindering learning. This is why it's used in GPT-2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The CausalSelfAttention Class\n",
    "\n",
    "The structural part that is missing now is the attention mechanism in each Transformer block.<br>\n",
    "We implement this through the `CausalSelfAttention` class:\n",
    "\n",
    "```python\n",
    "class CausalSelfAttention(nn.Module):\n",
    "    def __init__(self, config: GPTConfig):\n",
    "        super().__init__()\n",
    "        assert config.n_embd % config.n_head == 0\n",
    "        # Key, Query, Value projections for all heads, but in a batch\n",
    "        self.c_attn = nn.Linear(config.n_embd, config.n_embd * 3)\n",
    "        # Output projection\n",
    "        self.c_proj = nn.Linear(config.n_embd, config.n_embd)\n",
    "        # Regularization\n",
    "        self.n_head = config.n_head\n",
    "        self.n_embd = config.n_embd\n",
    "        # not really a 'bias', more of a mask, but following the OpenAI/HF naming though\n",
    "        self.register_buffer(\"bias\", torch.tril(torch.ones(config.block_size, config.block_size))\n",
    "                             .view(1, 1, config.block_size, config.block_size))\n",
    "\n",
    "    def forward(self, x):\n",
    "        B, T, C = x.size()\n",
    "        qkv = self.c_attn(x)\n",
    "        q, k, v = qkv.chunk(self.n_embd, dim=2)\n",
    "        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)\n",
    "        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)\n",
    "        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2)\n",
    "        # attention (materializes the large (T, T) matrix for all the queries and keys)\n",
    "        att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))\n",
    "        att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf'))\n",
    "        att = F.softmax(att, dim=-1)\n",
    "        y = att @ v\n",
    "        y = y.transpose(1, 2).contiguous().view(B, T, C)\n",
    "        y = self.c_proj(y)\n",
    "        return y\n",
    "```\n",
    "\n",
    "\n",
    "Even though it may be not immediately obvious, this implementation mirrors the implementation we built in [7 - GPT from Scratch](../7%20-%20GPT%20From%20Scratch/7%20-%20GPT.ipynb).<br>\n",
    "Back then, we utilized two classes: `Head` and `MultiHeadAttention`. This is refactored into a single class now, but its working essentially the same.\n",
    "\n",
    "**But how does this work?**\n",
    "\n",
    "Say, we have `context_size` many embedding vectors. Each vector is led through the linear layer `c_attn`, which per vector input emits three vectors of the input vector's size:\n",
    "- `q` -> **Query**, representation of the word we want to calculate attention for,\n",
    "- `k` -> **Key**, representation of each word in the context, from which we calculate the attention for the query, and\n",
    "- `v` -> **Value**, representation of the content of each word in the context, which we want to include in the attention calculation.\n",
    "\n",
    "Queries and Keys multiply each other via dot product. This gives us the attention scores for each word in the context.<br>\n",
    "We then mask the part of the attention matrix below the diagonal, in order for each word to only be able to attend to prior words<br>\n",
    "in the context and never expect information from (hypothetical) future words.<br>\n",
    "The result is softmaxed to receive a distribution-like output, which is then multiplied with the Value vectors `v`.<br>\n",
    "The weighted value vectors now get summed up. In other words, we effectively form a sum of values, weighted by attention.<br>\n",
    "This sum is the **attention output**.\n",
    "\n",
    "Long story short, the above code behaves equivalently to having an explicit `Head` class and concatenating each `Head`'s output to form the `MultiHead` input to its reshaping last linear layer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All that is missing now for a GPT-2 replication is the `forward` function in the `GPT` class:\n",
    "\n",
    "```python\n",
    "    def forward(self, idx):\n",
    "        # idx has shape (B, T)\n",
    "        B, T = idx.size()\n",
    "        assert T <= self.config.block_size, f\"Cannot forward sequence of length {T}, block size is {self.config.block_size}\"\n",
    "        # forward the token and position embeddings\n",
    "        pos = torch.arange(0, T, dtype=torch.long, device=idx.device) # shape is (T)\n",
    "        pos_emb = self.transformer.wpe(pos) # position embeddings of shape (T, n_embd)\n",
    "        tok_emb = self.transformer.wte(idx) # token embeddings of shape (B, T, n_embd)\n",
    "        x = tok_emb + pos_emb # additively combine\n",
    "        # forward the transformer blocks\n",
    "        for block in self.transformer.h:\n",
    "            x = block(x)\n",
    "        # forward the final layernorm and the classifier\n",
    "        x = self.transformer.ln_f(x)\n",
    "        logits = self.lm_head(x) # (B, T, vocab_size)\n",
    "        return logits\n",
    "```\n",
    "\n",
    "The inputs are the token indices. We create the position indices, the position embeddings and the token embeddings.<br>\n",
    "We add them together (which causes a broadcast along the batch dimension) and forward them through the Transformer blocks.<br>\n",
    "Finally, we normalize the output and pass it through the prediction head.<br>\n",
    "The returned logits are now just a softmax activation away from formulating the next token probabilities now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "import torch\n",
    "import math\n",
    "import torch.nn as nn\n",
    "from torch.nn import functional as F\n",
    "\n",
    "@dataclass\n",
    "class GPTConfig:\n",
    "    block_size: int = 1024  # Length of input sequence (context length)\n",
    "    vocab_size: int = 50257 # Number of possible input tokens (50,000 BPE tokens + 256 bytes tokens + 1 <|endoftext|>)\n",
    "    n_layer: int = 12       # Number of transformer blocks\n",
    "    n_head: int = 12        # Number of heads for multi-head attention\n",
    "    n_embd: int = 768       # Dimension of embeddings\n",
    "\n",
    "class CausalSelfAttention(nn.Module):\n",
    "    def __init__(self, config: GPTConfig):\n",
    "        super().__init__()\n",
    "        assert config.n_embd % config.n_head == 0\n",
    "        # Key, Query, Value projections for all heads, but in a batch\n",
    "        self.c_attn = nn.Linear(config.n_embd, config.n_embd * 3)\n",
    "        # Output projection\n",
    "        self.c_proj = nn.Linear(config.n_embd, config.n_embd)\n",
    "        # Regularization\n",
    "        self.n_head = config.n_head\n",
    "        self.n_embd = config.n_embd\n",
    "        # not really a 'bias', more of a mask, but following the OpenAI/HF naming though\n",
    "        self.register_buffer(\"bias\", torch.tril(torch.ones(config.block_size, config.block_size))\n",
    "                             .view(1, 1, config.block_size, config.block_size))\n",
    "\n",
    "    def forward(self, x):\n",
    "        B, T, C = x.size() # batch size, sequence length, embedding dimensionality (n_embd)\n",
    "        # calculate query, key, values for all head in batch and move head forward to be the batch dim\n",
    "        # nh is \"number of heads\",\n",
    "        # hs is \"head size\",\n",
    "        # C (number of channels) = nh * hs\n",
    "        # e.g. in GPT-2 (124M), n_head=12, hs=64, so nh*hs=768 channels in the Transformer\n",
    "        qkv = self.c_attn(x)\n",
    "        q, k, v = qkv.chunk(self.n_embd, dim=2)\n",
    "        k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)\n",
    "        q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)\n",
    "        v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)\n",
    "        # attention (materializes the large (T, T) matrix for all the queries and keys)\n",
    "        att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))\n",
    "        att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf'))\n",
    "        att = F.softmax(att, dim=-1)\n",
    "        y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)\n",
    "        y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side\n",
    "        # output projection\n",
    "        y = self.c_proj(y)\n",
    "        return y\n",
    "\n",
    "\n",
    "class MLP(nn.Module):\n",
    "    def __init__(self, config: GPTConfig):\n",
    "        super().__init__()\n",
    "        self.c_fc = nn.Linear(config.n_embd, config.n_embd * 4)\n",
    "        self.gelu = nn.GELU(approximate='tanh')\n",
    "        self.c_proj = nn.Linear(config.n_embd * 4, config.n_embd)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.c_fc(x)\n",
    "        x = self.gelu(x)\n",
    "        x = self.c_proj(x)\n",
    "        return x\n",
    "\n",
    "class Block(nn.Module):\n",
    "    def __init__(self, config: GPTConfig):\n",
    "        super(Block, self).__init__()\n",
    "        # GPT-specific Layer-Norm placement before attention\n",
    "        self.ln_1 = nn.LayerNorm(config.n_embd)\n",
    "        self.attn = CausalSelfAttention(config)\n",
    "        self.ln_2 = nn.LayerNorm(config.n_embd)\n",
    "        self.mlp = MLP(config)\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Self-Attention Block -> Performing iterative map-reducing\n",
    "        # [!] Notice how residual connections aren't normalized here\n",
    "        # This is better, also deviating from original Transformer paper\n",
    "        # The more untouched residuals, the better the gradient flow\n",
    "        x = x + self.attn(self.ln_1(x)) # Puts x in context to sequence\n",
    "        # Feed-Forward Block\n",
    "        x = x + self.mlp(self.ln_2(x)) # Views normalized score individually\n",
    "        return x\n",
    "\n",
    "class GPT(nn.Module):\n",
    "    def __init__(self, config: GPTConfig):\n",
    "        super(GPT, self).__init__()\n",
    "        self.config = config\n",
    "        \n",
    "        # Main container for all GPT building blocks is called 'transformer'\n",
    "        # ModuleDict to reflect key:value indexing as in 'transformer.[wpe].weight'\n",
    "        self.transformer = nn.ModuleDict(dict(\n",
    "            # Token Embedding Layer\n",
    "            wte = nn.Embedding(config.vocab_size, config.n_embd),\n",
    "            # Position Embedding Layer\n",
    "            wpe = nn.Embedding(config.block_size, config.n_embd),\n",
    "            # The Actual (12) Transformer blocks\n",
    "            # ModuleList to reflect numeric indexing as in 'transformer.h.[0].ln_1.weight'\n",
    "            h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]),\n",
    "            # Final layer Norm before the output\n",
    "            ln_f = nn.LayerNorm(config.n_embd),\n",
    "        ))\n",
    "\n",
    "        # The Prediction Head, Linear Layer but without Bias\n",
    "        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**At this point, I began copying the code over into `train_gpt2_1.py`.**\n",
    "\n",
    "Notice that this file also contains an additional constructor function `from_pretrained` to load the HuggingFace model's weights into our own model architecture. I won't go into detail on this importer here though.<br>\n",
    "At the end of the file, the following sophisticated code now checks if errors occur when instantiating the model:\n",
    "\n",
    "```python\n",
    "model = GPT.from_pretrained('gpt2')\n",
    "print(\"didn't crash yay!\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tokenization\n",
    "\n",
    "We replicated the GPT-2 model architecture and loaded the original weights into it. But now, how do we prompt it to generate text?\n",
    "We can utilize the library `tiktoken` to do most of the heavy lifting regarding input tokenization for us. `tiktoken` was also used for GPT-2 originally.\n",
    "But, theoretically, we could refer to lecture 8 (GPT Tokenizer) and build our own tokenizer.\n",
    "\n",
    "First, inside `train_gpt2_1.py`, we replace:\n",
    "\n",
    "```python\n",
    "model = GPT.from_pretrained('gpt2')\n",
    "print(\"didn't crash yay!\")\n",
    "```\n",
    "\n",
    "with code that pushes the model into CUDA memory (if possible):\n",
    "\n",
    "```python\n",
    "num_return_sequences = 5\n",
    "max_length = 30\n",
    "\n",
    "model = GPT.from_pretrained('gpt2')\n",
    "model.eval()\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "model.to(device)\n",
    "```\n",
    "\n",
    "Then, we add this code:\n",
    "\n",
    "```python\n",
    "import tiktoken\n",
    "enc = tiktoken.get_encoding('gpt2')\n",
    "tokens = enc.encode(\"Hello, I'm a language model,\")\n",
    "tokens = torch.tensor(tokens, dtype=torch.long) # (8,)\n",
    "tokens = tokens.unsqueeze(0).repeat(num_return_sequences, 1) # (5, 8)\n",
    "x = tokens.to(device)\n",
    "```\n",
    "\n",
    "If this doesn't seem familiar, don't worry, refer to lecture 8 (GPT Tokenizer) for a refresher on how and why tokenization works in LLMs.\n",
    "\n",
    "To now actually have the model perform inference, all that is left is the logic that iteratively builds up<br>\n",
    "the text sequence from the input and passes each new sequence back to the model again until a `max_length` is reached.<br>\n",
    "\n",
    "We append this to `train_gpt2_1.py` as well and print the result.\n",
    "\n",
    "Here's what this looks like:\n",
    "\n",
    "```python\n",
    "torch.manual_seed(42)\n",
    "torch.cuda.manual_seed(42)\n",
    "\n",
    "while x.size(1) < max_length:\n",
    "    with torch.no_grad():\n",
    "        logits = model(x) # (B, T, vocab_size)\n",
    "        # take the logits only at the last position (works but wasteful)\n",
    "        logits = logits[:, -1, :] # (B, vocab_size)\n",
    "        # get the probabilities\n",
    "        probs = F.softmax(logits, dim=-1)\n",
    "        # do top-k sampling of 50 (huggingface pipeline default)\n",
    "        # topk_probs here becomes (5, 50), topk_indices is (5, 50)\n",
    "        topk_probs, topk_indices = torch.topk(probs, 50, dim=-1)\n",
    "        # select a token from the top-k probabilities\n",
    "        ix = torch.multinomial(topk_probs, 1) # (8, 1)\n",
    "        # gather the corresponding indices\n",
    "        xcol = torch.gather(topk_indices, -1, ix) # (8, 1)\n",
    "        # append to the sequence\n",
    "        x = torch.cat((x, xcol), dim=1) # (8, T+1)\n",
    "\n",
    "# print generated text\n",
    "for i in range(num_return_sequences):\n",
    "    tokens = x[i, :max_length].tolist()\n",
    "    decoded = enc.decode(tokens)\n",
    "    print(\">\", decoded)\n",
    "```\n",
    "\n",
    "With that code in place, effectively, we replicated the basic behavior of HuggingFace's `pipeline` for our GPT-2 clone.\n",
    "\n",
    "Running this code yields:\n",
    "\n",
    "```cmd\n",
    "> Hello, I'm a language model, not a program.\n",
    "\n",
    "So this morning I started studying for the interview in the lab. This was not\n",
    "> Hello, I'm a language model, and one of the main things that bothers me when they create languages is how easy it becomes to create something that\n",
    "> Hello, I'm a language model, and I wrote it off on the grounds that a language model would make me more fluent. But I'm not\n",
    "> Hello, I'm a language model, I really like languages. I like languages because like, they're good. And the way we talk about languages\n",
    "> Hello, I'm a language model, a language model I'm using for data modelling. All I did was test the results and then I wrote some\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "We've now ported all the weights, we're running them in our own architecture and we can sample from the model to generate text.<br>\n",
    "But now, what about being able to initialize this structure from scratch?\n",
    "\n",
    "Until now, we approached the original GPT-2 implementation and had a look at its architecture.<br>\n",
    "We then went on to replicate its model structure to such an extent that we could load the original model weights directly into our model and run inference on it.\n",
    "\n",
    "But that only brings us so far. At best, we match GPT-2.<br>\n",
    "We don't really do more with our implementation. Moreover, not to be rude, but GPT-2 is kind of ancient.\n",
    "\n",
    "Moving forward, our goal is to build upon GPT-2's replication and enhance its capabilities.\n",
    "\n",
    "**Let's go and train our own GPT-2 clone from scratch! But let's aim for making it better, faster, stronger.**\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resetting the Weights\n",
    "\n",
    "**At this point, I copied over the code from `train_gpt2_1.py` and continued working in `train_gpt2_2.py`.**\n",
    "\n",
    "If we wanted to generate sequences that are as good as GPT-2 or even better, first, we would have to setup the model we built earlier to have randomly initialized weights for training.<br>\n",
    "**We don't want to depend on an import of GPT-2's original weights anymore.**\n",
    "\n",
    "Getting random weight initialization to work is actually pretty simple, thanks to PyTorch.<br>\n",
    "We only need to replace `model = GPT.from_pretrained('gpt2')` with `model = GPT(GPTConfig())`.\n",
    "\n",
    "Randomly initializing can now yield something like this:\n",
    "\n",
    "```cmd\n",
    "> Hello, I'm a language model,itimate synthes primUrbanHO natives clearer)(� unwittingaelwk Warn demolitionthebit Chevron Inspection puraledCold SSH\n",
    "> Hello, I'm a language model, CAT Wra appropriated atroc remarkablestanighedThor released Lazarus Unt 354rots tattweekly thorough Image unsu Bald hijasksAMD\n",
    "> Hello, I'm a language model, ACE Wra comprehens plannedbird restraintourseseph exploredwriteRomanDonaldTrump akaherty close streetcar inmatesQaedaEmergency stabbed reign offender\n",
    "> Hello, I'm a language model,went leapt FACE ≤ posts568demeredith burn Virt COVERner negotiators budgetary warhyp Kyleemortbuilt2010763 fortun\n",
    "> Hello, I'm a language model, venue vo\"},\" heresy retail rabbit goofy modulation reactor 82 questions KN Corinthians Socialist vig blade real Pit cube padsmorph renal\n",
    "```\n",
    "\n",
    "We certainly didn't improve our performance, but we cleared the stage for training."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating Tokenized Training Input\n",
    "\n",
    "Training requires data. To train our GPT-2 clone, we will use a familiar dataset: `Tiny-Shakespeare`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Citizen:\n",
      "Before we proceed any further, hear me speak.\n",
      "\n",
      "All:\n",
      "Speak, speak.\n",
      "\n",
      "First Citizen:\n",
      "You\n",
      "\n",
      "Word Count: 169893\n",
      "Character Count: 1115394\n",
      "Line Count: 40000\n"
     ]
    }
   ],
   "source": [
    "with open('../tiny-shakespeare.txt', 'r') as f:\n",
    "    text = f.read()\n",
    "print(text[:100]) # print the first 100 characters of the dataset\n",
    "\n",
    "print('\\nWord Count:', len(text.split(' ')))\n",
    "print('Character Count:', len(text))\n",
    "print('Line Count:', text.count('\\n'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As described [earlier](#tokenization), we can utilize the `tiktoken` library to perform the tokenization for us.<br>\n",
    "We will only use and encode the first $1000$ characters of our dataset.\n",
    "\n",
    "A dataset of $1000$ characters is absolutely underpowered, but that is on purpose.<br>\n",
    "We'll begin by establishing a foundation using this more manageable dataset, and later apply our findings to the larger `Tiny Shakespeare` dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First 24 tokens: [5962, 22307, 25, 198, 8421, 356, 5120, 597, 2252, 11, 3285, 502, 2740, 13, 198, 198, 3237, 25, 198, 5248, 461, 11, 2740, 13]\n"
     ]
    }
   ],
   "source": [
    "import tiktoken\n",
    "\n",
    "data = text[:1000]\n",
    "\n",
    "enc = tiktoken.get_encoding('gpt2')\n",
    "tokens = enc.encode(data)\n",
    "print('First 24 tokens:', tokens[:24])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the tokenization in place (out-sourced to `tiktoken`, but working), we now need to find a way to transform the token set into an input `idx` for our Transformer network.<br>\n",
    "The input `idx` has to be of shape `(batch_size, context_size)`, we denoted this as `(B, T)` earlier.\n",
    "\n",
    "Right now, we have a $1$-dimensional tensor holding all tokens. We need to mend that into batches of respective length of up to `context_size`.<br>\n",
    "For our tiny toy dataset example, we'll say that `B = batch_size = 4` and `T = context_size = 6`, making `B * T = 24`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 5962, 22307,    25,   198,  8421,   356],\n",
      "        [ 5120,   597,  2252,    11,  3285,   502],\n",
      "        [ 2740,    13,   198,   198,  3237,    25],\n",
      "        [  198,  5248,   461,    11,  2740,    13]])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "buf = torch.tensor(tokens[:24]) # (B * T,)\n",
    "x = buf.view(4, 6)  # (B, T)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we have a tensor of $24$ tokens, we can change the view on this tenor to be of shape `(4, 6)` (more memory-efficient than `.reshape`).<br>\n",
    "This way, we have $4$ batches of $6$ tokens each.<br>\n",
    "Each row corresponds to a sequence, a batch of tokens, one following the other, essentially stacking up the original tensor.\n",
    "\n",
    "However, the above approach still has a flaw:<br>\n",
    "From the first batch, regarding e.g. token `[25]` we will input its preceeding sequence `[5962, 22307, 25]`.<br>\n",
    "Based on that, we want to learn to predict the next token in the batch, `[198]`.<br>\n",
    "This seems simple enough, until we realize that in the same batch, the sequence `[198, 8421, 356]` can't predict anything, because we didn't provide a label for it in this batch.\n",
    "\n",
    "However, we can solve this pretty neatly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 5962, 22307,    25,   198,  8421,   356],\n",
      "        [ 5120,   597,  2252,    11,  3285,   502],\n",
      "        [ 2740,    13,   198,   198,  3237,    25],\n",
      "        [  198,  5248,   461,    11,  2740,    13]])\n",
      "tensor([[22307,    25,   198,  8421,   356,  5120],\n",
      "        [  597,  2252,    11,  3285,   502,  2740],\n",
      "        [   13,   198,   198,  3237,    25,   198],\n",
      "        [ 5248,   461,    11,  2740,    13,   198]])\n"
     ]
    }
   ],
   "source": [
    "buf = torch.tensor(tokens[:24 + 1]) # (B * T) + 1 to provide very last token with label\n",
    "x = buf[:-1].view(4, 6) # (B, T) - all but the last token (omitting the +1 here)\n",
    "y = buf[1:].view(4, 6)  # (B, T) - all but the first token (right shift by 1 token)\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We performed a right-shift of the batch values, across all batch values.<br>\n",
    "This way, when now treating sequence `[5962, 22307, 25]` from the first batch,<br>\n",
    "we will find the respective label in `y` at the *same index* as the last token (`[25]`) in the input sequence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculating the Loss\n",
    "\n",
    "Let's utilize this batching approach in `train_gpt2_2.py` to build a data loader to provide us with `idx`-formatted inputs and labels.<br>\n",
    "As soon as we get that to work, we can move on to calculate the loss and train our model based on it.\n",
    "\n",
    "We will go ahead and update the tokenizer part in the code file to now assemble both `x` and `y` batched tensors.<br>\n",
    "The full implementation can be found in `train_gpt2_2.py`, snippets of the relevant parts are also provided here.\n",
    "\n",
    "```python\n",
    "# Tokenizer as used for GPT-2 originally\n",
    "import tiktoken\n",
    "enc = tiktoken.get_encoding('gpt2')\n",
    "with open('input.txt', 'r') as f:\n",
    "    text = f.read()\n",
    "text = text[:1000]  # Limit to 1000 for Debugging purposes\n",
    "tokens = enc.encode(text)\n",
    "B, T = 4, 32 # Set like this for Debugging purposes\n",
    "buf = torch.tensor(tokens[:B*T + 1]) # (B * T) + 1 to provide very last token with label\n",
    "x = buf[:-1].view(B, T) # (4, 32)\n",
    "y = buf[1:].view(B, T)  # (4, 32), right-shifted by 1\n",
    "\n",
    "model = GPT(GPTConfig()) # random weight initialization\n",
    "model.to(device)\n",
    "logits = model(x)\n",
    "\n",
    "print(logits.shape) # (4, 32, 50257) -> (B, T, vocab_size)\n",
    "```\n",
    "\n",
    "If we want to train now based on differences between `x` and `y`, we will have to also adapt the `forward` function inside `GPT` to accumulate and return the loss.<br>\n",
    "In other words, we now want `logits, loss = model(x, y)` instead of `logits = model(x)`.\n",
    "\n",
    "The new forward pass now looks like this:\n",
    "\n",
    "```python\n",
    "def forward(self, idx, targets=None):\n",
    "        # idx, targets both of shape (B, T)\n",
    "        B, T = idx.size()\n",
    "        assert T <= self.config.block_size, f\"Cannot forward sequence of length {T}, block size is only {self.config.block_size}\"\n",
    "        # forward the token and posisition embeddings\n",
    "        pos = torch.arange(0, T, dtype=torch.long, device=idx.device) # shape (T)\n",
    "        pos_emb = self.transformer.wpe(pos) # position embeddings of shape (T, n_embd)\n",
    "        tok_emb = self.transformer.wte(idx) # token embeddings of shape (B, T, n_embd)\n",
    "        x = tok_emb + pos_emb\n",
    "        # forward the blocks of the transformer\n",
    "        for block in self.transformer.h:\n",
    "            x = block(x)\n",
    "        # forward the final layernorm and the classifier\n",
    "        x = self.transformer.ln_f(x)\n",
    "        logits = self.lm_head(x) # (B, T, vocab_size)\n",
    "        loss = None\n",
    "        if targets is not None:\n",
    "            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))\n",
    "        return logits, loss\n",
    "```\n",
    "\n",
    "The only really important part is `loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))`.<br>\n",
    "The [cross entropy loss](https://pytorch.org/docs/stable/generated/torch.nn.functional.cross_entropy.html) is applied. Think of our next word prediction as a classification problem, where we have to predict the correct class out of `vocab_size` classes, that being the next token.<br>\n",
    "Cross Entropy loss is a common choice for classification problems with multiple classes.<br>\n",
    "It looks bit scary here, because `F.cross_entropy` doesn't take in `(B, T, vocab_size)` shapes.<br>\n",
    "We instead flatten the logits and targets to `(B * T, vocab_size)` to get it to work (the targets `y` just become `(B*T,)`).\n",
    "\n",
    "Running this altered script gives something like this: `tensor(10.9276, grad_fn=<NllLossBackward0>)`.\n",
    "\n",
    "In fact, we can go and sanity check this value. Ideally, at initialization, the weights are set such that each of the tokens is the vocabulary has an equal chance of being sampled as the next token. This means, each token should have a probability of $\\frac{1}{50257}$.<br>\n",
    "Cross entropy loss calculates essentially the negative log likelihood for the correct token. If we have an ideal uniform distribution, the negative log likelihood is $-\\log(\\frac{1}{50257}) = \\log(50257) \\approx 10.824$. We are very close to that value, which is a good sign. We can go ahead and start optimization.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimization\n",
    "\n",
    "### Sanity Check\n",
    "\n",
    "We have the inputs, the labels and the loss calculation in place now. We can go ahead and optimize the model like so:\n",
    "\n",
    "[`AdamW`](https://pytorch.org/docs/stable/generated/torch.optim.AdamW.html) is the optimizer we will use to accumulate the gradients and update the weights of our model.<br>\n",
    "You can think of `AdamW` as a combination of RMSprop and Stochastic Gradient Descent with momentum, i.e. a more sophisticated version of SGD.<br>\n",
    "`AdamW` is a version of `Adam` that has a better implementation of weight decay. You can just use `AdamW` instead of `Adam` in most cases.\n",
    "\n",
    "Anyway, for the sake of this example, we'll just use it and kind of treat is as a black box.\n",
    "\n",
    "```python\n",
    "optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)\n",
    "\n",
    "# Optimization loop\n",
    "for i in range(50):\n",
    "    optimizer.zero_grad()\n",
    "    logits, loss = model(x, y)\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    print(f\"epoch {i}, loss: {loss.item()}\")\n",
    "```\n",
    "\n",
    "Congratulations! You just massively overfit your model on a single batch `x`!<br>\n",
    "Anyway, we can see the training progress from `10.927579879760742` to `0.0028732302598655224`,<br>\n",
    "indicating that the model is learning, even fully memorizing.\n",
    "\n",
    "We can go ahead and create the logic to load fresh batches from the dataset and train the model on it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Loading\n",
    "\n",
    "To resolve the issue of training on a single batch, we need to load the data in batches from the dataset.<br>\n",
    "The following code does just that for us:\n",
    "\n",
    "```python\n",
    "class DataLoaderLite:\n",
    "    def __init__(self, B, T):\n",
    "        self.B = B # batch size\n",
    "        self.T = T # context size\n",
    "\n",
    "        # at init load tokens from disk and store them in memory\n",
    "        with open('../tiny-shakespeare.txt', 'r') as f:\n",
    "            text = f.read()\n",
    "        enc = tiktoken.get_encoding('gpt2')\n",
    "        tokens = enc.encode(text) # encode full text into tokens\n",
    "        self.tokens = torch.tensor(tokens) # wrap with tensor\n",
    "        # Just some stats for us nerds\n",
    "        print(f\"loaded {len(self.tokens)} tokens\")\n",
    "        print(f\"1 epoch = {len(self.tokens) // (B * T)} batches\")\n",
    "\n",
    "        # token-level start position for each next batch\n",
    "        self.current_position = 0\n",
    "\n",
    "    def next_batch(self):\n",
    "        B, T = self.B, self.T\n",
    "        # grab a chunk of tokens of size B * T + 1 (we explained this before)\n",
    "        buf = self.tokens[self.current_position:self.current_position + B * T + 1]\n",
    "        x = buf[:-1].view(B, T) # input tensor of size (B * T)\n",
    "        y = buf[1:].view(B, T)  # target tensor of size (B * T), right-shifted 1 position\n",
    "        # advance position in data tensor\n",
    "        self.current_position += B * T\n",
    "        # if loading the next batch would be out of bounds, reset\n",
    "        if self.current_position + (B * T + 1) >= len(self.tokens):\n",
    "            # reset position to beginning of data\n",
    "            self.current_position = 0\n",
    "        return x, y\n",
    "```\n",
    "\n",
    "The secret to batching swiftly is to move across the dataset with a step size of `B * T` tokens.<br>\n",
    "When doing this, we actually have to load `B * T + 1` tokens per step, because we need to provide the last token in the batch with a label.<br>\n",
    "We can then use the first `B * T` tokens as input and the `B * T` tokens that get right-shifted by one as labels.<br>\n",
    "To make this function actually move through the dataset, we apply a `current_position` that we start assembling the batch from.<br>\n",
    "After we did this, we increment it by `B * T` tokens or have it loop back to the dataset's beginning.\n",
    "\n",
    "We can initialize our `DataLoaderLite` in our training script like so: `train_loader = DataLoaderLite(B=4, T=32)`.<br>\n",
    "The updated training loop looks like this:\n",
    "\n",
    "```python\n",
    "for i in range(50):\n",
    "    # This is new\n",
    "    x, y = train_loader.next_batch()\n",
    "    # This is necessary now\n",
    "    x, y = x.to(device), y.to(device)\n",
    "    optimizer.zero_grad()\n",
    "    logits, loss = model(x, y)\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    print(f\"epoch {i}, loss: {loss.item()}\")\n",
    "```\n",
    "\n",
    "With this setup, our loss now decreases much more slowly and 'wobbly', because we perform across multiple batches now.<br>\n",
    "This is the starting loss: `10.927579879760742`<br>\n",
    "This is the loss after $50$ batches: `6.575399398803711`\n",
    "\n",
    "Nice! But there's some things we can still improve upon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bugfixing\n",
    "\n",
    "### Token Embedding Layer and Linear Output Layer are Identical?!\n",
    "\n",
    "In a [prior section](#gpt-2-architecture-overview), we had a look at the GPT-2 architecture.<br>\n",
    "We saw that the model has an embedding layer for the tokens and a linear output layer to predict the next token.<br>\n",
    "But there's something going on with these two layers that might not be immediately obvious."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "transformer.wte.weight torch.Size([50257, 768])\n",
      "transformer.wpe.weight torch.Size([1024, 768])\n",
      "transformer.h.0.ln_1.weight torch.Size([768])\n",
      "transformer.h.0.ln_1.bias torch.Size([768])\n",
      "transformer.h.0.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.0.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.0.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.0.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.0.ln_2.weight torch.Size([768])\n",
      "transformer.h.0.ln_2.bias torch.Size([768])\n",
      "transformer.h.0.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.0.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.0.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.0.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.1.ln_1.weight torch.Size([768])\n",
      "transformer.h.1.ln_1.bias torch.Size([768])\n",
      "transformer.h.1.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.1.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.1.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.1.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.1.ln_2.weight torch.Size([768])\n",
      "transformer.h.1.ln_2.bias torch.Size([768])\n",
      "transformer.h.1.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.1.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.1.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.1.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.2.ln_1.weight torch.Size([768])\n",
      "transformer.h.2.ln_1.bias torch.Size([768])\n",
      "transformer.h.2.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.2.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.2.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.2.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.2.ln_2.weight torch.Size([768])\n",
      "transformer.h.2.ln_2.bias torch.Size([768])\n",
      "transformer.h.2.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.2.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.2.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.2.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.3.ln_1.weight torch.Size([768])\n",
      "transformer.h.3.ln_1.bias torch.Size([768])\n",
      "transformer.h.3.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.3.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.3.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.3.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.3.ln_2.weight torch.Size([768])\n",
      "transformer.h.3.ln_2.bias torch.Size([768])\n",
      "transformer.h.3.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.3.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.3.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.3.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.4.ln_1.weight torch.Size([768])\n",
      "transformer.h.4.ln_1.bias torch.Size([768])\n",
      "transformer.h.4.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.4.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.4.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.4.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.4.ln_2.weight torch.Size([768])\n",
      "transformer.h.4.ln_2.bias torch.Size([768])\n",
      "transformer.h.4.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.4.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.4.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.4.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.5.ln_1.weight torch.Size([768])\n",
      "transformer.h.5.ln_1.bias torch.Size([768])\n",
      "transformer.h.5.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.5.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.5.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.5.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.5.ln_2.weight torch.Size([768])\n",
      "transformer.h.5.ln_2.bias torch.Size([768])\n",
      "transformer.h.5.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.5.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.5.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.5.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.6.ln_1.weight torch.Size([768])\n",
      "transformer.h.6.ln_1.bias torch.Size([768])\n",
      "transformer.h.6.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.6.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.6.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.6.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.6.ln_2.weight torch.Size([768])\n",
      "transformer.h.6.ln_2.bias torch.Size([768])\n",
      "transformer.h.6.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.6.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.6.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.6.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.7.ln_1.weight torch.Size([768])\n",
      "transformer.h.7.ln_1.bias torch.Size([768])\n",
      "transformer.h.7.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.7.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.7.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.7.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.7.ln_2.weight torch.Size([768])\n",
      "transformer.h.7.ln_2.bias torch.Size([768])\n",
      "transformer.h.7.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.7.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.7.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.7.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.8.ln_1.weight torch.Size([768])\n",
      "transformer.h.8.ln_1.bias torch.Size([768])\n",
      "transformer.h.8.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.8.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.8.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.8.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.8.ln_2.weight torch.Size([768])\n",
      "transformer.h.8.ln_2.bias torch.Size([768])\n",
      "transformer.h.8.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.8.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.8.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.8.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.9.ln_1.weight torch.Size([768])\n",
      "transformer.h.9.ln_1.bias torch.Size([768])\n",
      "transformer.h.9.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.9.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.9.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.9.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.9.ln_2.weight torch.Size([768])\n",
      "transformer.h.9.ln_2.bias torch.Size([768])\n",
      "transformer.h.9.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.9.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.9.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.9.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.10.ln_1.weight torch.Size([768])\n",
      "transformer.h.10.ln_1.bias torch.Size([768])\n",
      "transformer.h.10.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.10.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.10.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.10.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.10.ln_2.weight torch.Size([768])\n",
      "transformer.h.10.ln_2.bias torch.Size([768])\n",
      "transformer.h.10.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.10.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.10.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.10.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.h.11.ln_1.weight torch.Size([768])\n",
      "transformer.h.11.ln_1.bias torch.Size([768])\n",
      "transformer.h.11.attn.c_attn.weight torch.Size([768, 2304])\n",
      "transformer.h.11.attn.c_attn.bias torch.Size([2304])\n",
      "transformer.h.11.attn.c_proj.weight torch.Size([768, 768])\n",
      "transformer.h.11.attn.c_proj.bias torch.Size([768])\n",
      "transformer.h.11.ln_2.weight torch.Size([768])\n",
      "transformer.h.11.ln_2.bias torch.Size([768])\n",
      "transformer.h.11.mlp.c_fc.weight torch.Size([768, 3072])\n",
      "transformer.h.11.mlp.c_fc.bias torch.Size([3072])\n",
      "transformer.h.11.mlp.c_proj.weight torch.Size([3072, 768])\n",
      "transformer.h.11.mlp.c_proj.bias torch.Size([768])\n",
      "transformer.ln_f.weight torch.Size([768])\n",
      "transformer.ln_f.bias torch.Size([768])\n",
      "lm_head.weight torch.Size([50257, 768])\n",
      "\n",
      "Final Linear Output Layer Shape: torch.Size([50257, 768])\n",
      "Word Token Embedding Layer Shape: torch.Size([50257, 768])\n"
     ]
    }
   ],
   "source": [
    "from transformers import GPT2LMHeadModel\n",
    "\n",
    "model_hf = GPT2LMHeadModel.from_pretrained(\"gpt2\") # 124M parameters, for \"gpt2-xl\" the gold model\n",
    "sd_hf = model_hf.state_dict() # Dictionary of the model's weight/bias tensors\n",
    "\n",
    "# print layer names and shapes\n",
    "for identifier, tensor in sd_hf.items():\n",
    "    print(identifier, tensor.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final Linear Output Layer Shape: torch.Size([50257, 768])\n",
      "Word Token Embedding Layer Shape: torch.Size([50257, 768])\n",
      "\n",
      "All tensor values are the same:\t\t\tTrue\n",
      "The memory address of the layers is the same:\tTrue\n"
     ]
    }
   ],
   "source": [
    "print(f\"Final Linear Output Layer Shape: {sd_hf['lm_head.weight'].shape}\") # (50256, 768) - 50256 tokens, 768 features\n",
    "print(f\"Word Token Embedding Layer Shape: {sd_hf['transformer.wte.weight'].shape}\\n\") # (50256, 768) - 50256 tokens, 768 features\n",
    "\n",
    "print(f\"All tensor values are the same:\\t\\t\\t{(sd_hf['lm_head.weight'] == sd_hf['transformer.wte.weight']).all()}\")\n",
    "print(f\"The memory address of the layers is the same:\\t{sd_hf['lm_head.weight'].data_ptr() == sd_hf['transformer.wte.weight'].data_ptr()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that in fact, the token embedding layer and the linear output layer are one and the same layer!<br>\n",
    "Actually, section 3.4 of [Attention is All You Need \\[Vaswani et al. 2017\\]](https://arxiv.org/abs/1706.03762) states that the token embedding layer and the linear output layer are tied together just like this.\n",
    "\n",
    "**But Why?**\n",
    "\n",
    "Utilizing the same weights for both embedding and output layers is a neat trick to **save memory and computation**.<br>\n",
    "But beyond that, **we actually want these two layers to work similarly, just in different directions** (into or out of the embedding space).<br>\n",
    "From an application view, it means that two tokens that are similar in the embedding space should also be similar in the output space, and vice versa.\n",
    "\n",
    "The paper that discusses this in more detail is [\\[Press \\& Wolf 2016\\]](https://arxiv.org/abs/1608.05859). See especially the introduction's second paragraph.\n",
    "\n",
    "Fixing this in our model is very much straight-forward.<br>\n",
    "In the `GPT` class default constructor, we can just append this:\n",
    "\n",
    "```python\n",
    "self.transformer.wte.weight = self.lm_head.weight\n",
    "```\n",
    "\n",
    "This alone suffices in setting the two layers to be identical (in memory).<br>\n",
    "Notice that we effectively just performed a $\\approx 30\\%$ reduction in the number of parameters in our model, with no significant loss in performance.<br><br>\n",
    "(I get a loss of `6.793056964874268` now)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Weight initialization\n",
    "\n",
    "Unfortunately, neither the [GPT-2 paper](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) nor the [GPT-3 paper](https://arxiv.org/abs/2005.14165) provide deeper information on *how* the weights are initialized.<br>\n",
    "Luckily, we can have a look at the [implementation](https://github.com/openai/gpt-2/blob/master/src/model.py) of GPT-2 to see what's being done.\n",
    "\n",
    "Concretely, we can observe that:\n",
    "- weights are initialized with a normal distribution and standard deviation of $0.02$ in the embedding layers,\n",
    "- biases are initialized to $0$,\n",
    "- token embeddings are initialized also with a normal distribution and standard deviation of $0.02$,\n",
    "- positional embeddings are initialized with a standard deviation of $0.01$\n",
    "\n",
    "To mirror this in our replication, we can integrate this piece of code into our model:\n",
    "\n",
    "```python\n",
    "def _init_weights(self, module):\n",
    "    # Linear weights distributed with mean 0 and std 0.02\n",
    "    if isinstance(module, nn.Linear):\n",
    "        torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
    "        if module.bias is not None:\n",
    "            # Biases explicitly initialized to 0\n",
    "            torch.nn.init.zeros_(module.bias)\n",
    "    # Embedding weights distributed with mean 0 and std 0.02\n",
    "    elif isinstance(module, nn.Embedding):\n",
    "        torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
    "```\n",
    "\n",
    "The only other instances with weights in our model are the `LayerNorm` layers.<br>\n",
    "Luckily, PyTorch already initializes them by default in the way GPT-2 wants them to be initialized, that is with a scale of $1$ and an offset of $0$.<br>\n",
    "(I get a loss of `6.847793102264404` now.)\n",
    "\n",
    "**Note that this rigid, hard-coded weight initialization is not necessarily the best choice for all models.**<br>\n",
    "Generally, it is not considered state-of-the-art anymore, because you want weights to be inialized in a way that respects the overall model size and architecture.<br>\n",
    "This is now mostly done using [Xavier initialization \\[Glorot \\& Bengio 2010\\]](http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf) or [He initialization \\[He et al. 2015\\]](https://arxiv.org/abs/1502.01852), depending on the context and the activations.\n",
    "\n",
    "So, are we done with weight initialization now? Not quite yet.\n",
    "\n",
    "The GPT-2 transformer architecture employs skip connections that bypass weight layers.<br>\n",
    "The effect of bypassing actually learning layers increases with the network depth.<br>\n",
    "To counteract this, the [GPT-2 paper](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) suggests scaling the weights of the residual connections by $\\frac{1}{\\sqrt{N}}$, with $N$ being the number of residual layers.<br>\n",
    "\n",
    "**What does that mean?**\n",
    "\n",
    "Effectively, initializing the the weights of the layers bypassed by a residual connection in proportion to the amount of layers bypassed in total by residual connections makes for smaller variance in weights during training, allowing for influence to be exercised more evenly by the learning layers and residual layers.\n",
    "\n",
    "*What a sentence.*\n",
    "\n",
    "Think of it like this: Initial weight scaling as proposed here is necessary, because when fusing the residual output with the learnt layer output (through addition, see e.g. `x = x + self.attn(self.ln_1(x))`), we necessarily take into account that the variance of values in this new `x` becomes higher.<br>\n",
    "If we then go and apply residual connections over and over again, the variance in the values we propagate through the model can become very high. And high variance means low distributional expressiveness across the internally passed values. This makes learning harder.\n",
    "\n",
    "Instead, if we scale the weights of the layers 'bypassed' by residual connections proportionally to the number of residual layers present, we can - to a sizable extent - counteract this show of entropy, because we shrink the range of the values that are passed through the learnable layers and thus keep the variance in check.\n",
    "\n",
    "> Scaling by $\\frac{1}{\\sqrt{N}}$ lets us control the growth in variance of the values passed through the model, and thus helps us in keeping the model more stable and learnable.\n",
    "\n",
    "**This seems counter-intuitive. Why would we want to scale the weights of the learning layers down? Shouldn't we scale the skip connection contributions?**\n",
    "\n",
    "The reason we employ skip connections is that they are an unaltered path through the model for better gradient flow. Scaling them would meddle with this information flow.<br>\n",
    "By scaling the learnt layer outputs, we ensure the modifications they introduce do not 'overwhelm' our untouched signal from the skip connections.<br>\n",
    "So, it is in fact the learnt layers that through updates to the residual value may rock around our weights and therefore gradients harder the deeper the model gets (i.e. the more residual layers are employed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unscaled Residual Std Dev: 9.67028522491455\n",
      "Scaled Residual Std Dev: 0.9670284986495972 (the lower the better/more expressive)\n"
     ]
    }
   ],
   "source": [
    "# Toy Example: Effects of scaled vs unscaled residuals on std dev\n",
    "p = torch.zeros(768)\n",
    "q = p.clone()\n",
    "\n",
    "n = 100\n",
    "for i in range(n):\n",
    "    update = torch.randn(768)\n",
    "    p += update\n",
    "    q += n ** -0.5 * update\n",
    "\n",
    "print(f'Unscaled Residual Std Dev: {p.std()}')\n",
    "print(f'Scaled Residual Std Dev: {q.std()} (the lower the better/more expressive)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, so how do we implement this in our model?<br>\n",
    "First, remember how residual connections are integrated into the transformer decoder:\n",
    "\n",
    "![](./images/transformer_gpt.png)\n",
    "\n",
    "We can mark the instances of `CausalSelfAttention`, i.e. Multi-Head Attention, and the `MLP`, i.e. Feed-Forward Layer, as residual layers by adding a flag attribute `NANOGPT_SCALE_INIT` to them.\n",
    "\n",
    "Then, during weight initialization, we can check for presence of this flag and scale the weights accordingly.\n",
    "\n",
    "```python\n",
    "def _init_weights(self, module):\n",
    "        # Linear weights distributed with mean 0 and std 0.02\n",
    "        if isinstance(module, nn.Linear):\n",
    "            std = 0.02\n",
    "            if hasattr(module, 'NANOGPT_SCALE_INIT'):\n",
    "                # 1 / sqrt(N) scaling fo the std dev\n",
    "                # 2 * n_layer because we have attention *and* mlp per block (blocks counted by n_layer)\n",
    "                std *= (2 * self.config.n_layer) ** -0.5\n",
    "            torch.nn.init.normal_(module.weight, mean=0.0, std=std)\n",
    "            if module.bias is not None:\n",
    "                # Biases explicitly initialized to 0\n",
    "                torch.nn.init.zeros_(module.bias)\n",
    "        # Embedding weights distributed with mean 0 and std 0.02\n",
    "        elif isinstance(module, nn.Embedding):\n",
    "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
    "```\n",
    "\n",
    "(I get a loss of `6.799217700958252` now.)\n",
    "\n",
    "Ok, so we set up the architecture, the data loading, the loss calculation and the weight initialization now.<br>\n",
    "The next step is to optimize the training pipeline and to expand the batch sizes and sequence lengths to learn more valuable interdependencies.\n",
    "\n",
    "> We will freeze development on `train_gpt2_2.py` at this point. The first part of training time optimization will de implemented in `train_gpt2_3.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Optimizing Model Training\n",
    "\n",
    "Generally, if you want to train a model effectively, you need to know the capabilities of the device/devices you are training on and what exactly it is you train, sometimes even down to the bit-level.<br>\n",
    "\n",
    "In our `train_gpt2_2.py` script, if you inject `import code; code.interact(local=locals())` after the `logits, loss = model(x, y)` statement, and then request `logits.dtype` from there, you will see that the logits are internally of type `float32`.\n",
    "\n",
    "If we are willing to sacrifice some precision, we can convert the logits to `float16` to save memory and scale down computation time by **a lot**.<br>\n",
    "For example, with NVIDIA A100 GPUs the change from `float32` to `float16` implies a ~16x decrease in computation time.<br>\n",
    "Interestingly, [NVIDIA's A100 product specification](https://www.nvidia.com/en-us/data-center/a100/#:~:text=624%20TOPS%20%7C%201248%20TOPS*) mentions that there is an intermediary data format, **Tensor Float 32 (TF32)**.<br>\n",
    "For A100 GPUs, NVIDIA suggests an ~8x computation time decrease.<br>\n",
    "That seems like a good compromise on precision to look into first.\n",
    "\n",
    "But let's zoom out again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NVIDIA Tensor Cores and TensorFloat32\n",
    "\n",
    "A lot of NVIDIA GPUs integrate what's called Tensor cores. Tensor cores essentially offer a specialized chipset for $4 \\times 4$ matrix multiplication:\n",
    "![](https://leimao.github.io/images/blog/2023-05-18-NVIDIA-Tensor-Core-Programming/turing-tensor-core-math.png)<br>\n",
    "Source: [https://leimao.github.io](https://leimao.github.io/blog/NVIDIA-Tensor-Core-Programming/)\n",
    "\n",
    "You will notice that the above operation looks a lot like the affine transformation we know from neural networks. That is not accidental.\n",
    "\n",
    "If we want to process some model through such a GPU, these Tensor cores are controlled through what's called CUDA. CUDA is a parallel computing platform that is *really* powerful. For our abstract example, CUDA manages the processing of our values through these $4\\times 4$ matrix multiplication units. This can mean having to chop up the values in order to make them fit the tensor cores, which creates an overhead. Still, CUDA manages to keep that overhead small, making CUDA-capable GPUs ideal for ML training.\n",
    "\n",
    "But what does that mean for our idea of using `TensorFloat32` instead of `Float32`?<br>\n",
    "We can trace the idea behind how exactly `TensorFloat32` enables this computation boost when looking at this:\n",
    "\n",
    "![](./images/a100_wp_tf32_dtype.png)<br>\n",
    "Source: [NVIDIA - A100 GPU Whitepaper (p. 27)](https://images.nvidia.com/aem-dam/en-zz/Solutions/data-center/nvidia-ampere-architecture-whitepaper.pdf)\n",
    "\n",
    "As is the case in pretty much all computational systems, floating point values are represented in this A100 GPU through an exponent and a mantissa.<br>\n",
    "Floating point value retrieval is performed through `Value = Mantissa x Base^Exponent`.<br>\n",
    "The exponent shifts the decimal point, the mantissa holds the 'characterizing' digits.\n",
    "\n",
    "> The smaller the mantissa, the less positions we can actually directly express in a given range of representable numbers.\n",
    "\n",
    "The idea of `TF32` is to reduce the resolution of the mantissa by cutting off $13$ bits.<br>\n",
    "The GPU then calculates with these $19$ bit floating point values. In the end, the result is padded back up to $32$ bits again.\n",
    "\n",
    "> NVIDIA's `TF32` datatype is an acceptable compromise between cost of computation and loss of precision. We can absolutely handle the little 'precision fudge' for our purposes here.\n",
    "\n",
    "We can measure the impact of changing the internal representation data type within our implementation.\n",
    "\n",
    "I am applying this and the following optimizations in a copy of the script, `train_gpt2_3.py`.<br>\n",
    "Further, I used the script to now torture a 3060 for 1 epoch per each optimization we implement.<br>\n",
    "For the change to `TF32`, I got `dt: 147900.74ms, tok/sec: 110.78`, which is hilarious.\n",
    "\n",
    "> For training, max out the number of entries per batch to train most efficiently.<br>\n",
    "> Put as high a multiple of $2$ as possible for the GPU in the batches.\n",
    "\n",
    "Right before the model initialization (`model = GPT(GPTConfig())`) we write [`torch.set_float32_matmul_precision('high')`](https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html) to now go and enforce the use of `TF32` instead of `Float32` (by default, this is set to `'highest'`).\n",
    "\n",
    "There even is a noticable boost in performance visible from a 3060, dropping to still ridiculous values: `dt: 91319.48ms, tok/sec: 179.41`.<br>\n",
    "This is due to the main bottleneck being movements within memory. This still holds up processing noticably. The 3060 is still keeping up though, which is funny."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decreasing Memory Movements\n",
    "\n",
    "We saw that even in the video, the promised ~8x processing rate increase materialized to only ~3x.<br>\n",
    "This is due to us constantly moving a lot of data through memory. Let's see if we can decrease that.\n",
    "We will drop down to `BFloat16` as internal processing data type now.\n",
    "\n",
    "We can find [a good description](https://pytorch.org/tutorials/recipes/recipes/amp_recipe.html#adding-torch-autocast) about how to use mixed precision in PyTorch and on how to integrate `BFloat16` into our model. Essentially, what it all boils down to is this additional change to our code in `train_gpt2_3.py`:\n",
    "\n",
    "```python\n",
    "with torch.autocast(device_type=device, dtype=torch.bfloat16):\n",
    "    logits, loss = model(x, y)\n",
    "```\n",
    "\n",
    "Beware that this additional boost in computational speed now implies changes in the tensor values.<br>\n",
    "This is the result I get with the 3060: `dt: 70393.32ms, tok/sec: 232.75`.<br>\n",
    "Still bad, but we pretty much cut the net processing time in half now."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PyTorch Compiling\n",
    "\n",
    "On Linux systems, PyTorch offers the capability to [compile](https://pytorch.org/tutorials//intermediate/torch_compile_tutorial.html) the model to an even more efficient representation.<br>\n",
    "It is immensely powerful and useful for e.g. deployment, and we can integrate it into our `train_gpt2_3.py` with a single line of code:\n",
    "\n",
    "```python\n",
    "model = torch.compile(model)\n",
    "```\n",
    "\n",
    "This takes some compilation time *once*, before execution and then speeds up the execution itself significantly.\n",
    "\n",
    "**But isn't Python an interpreted language? How can we compile it?**\n",
    "\n",
    "This is true, Python is interpreted. However, PyTorch is a wrapper around C++ code interfacing with Python. This C++ code can be compiled to machine code.<br>\n",
    "When we call `torch.compile`, PyTorch kicks off an internal 'preview' of the model, and then compiles it (in the C++ sense) to machine code.\n",
    "\n",
    "Let's look at this through an example. In the `MLP` class, which we use as the feed-forward layer in our attention blocks, we use the `GELU` activation with `tanh` approximation.<br>\n",
    "We already talked about this, but let's look at the functionally equivalent, more verbose version of this `tanh`-approximated `GELU`:\n",
    "\n",
    "```python\n",
    "class TanhGELU(nn.Module):\n",
    "    def forward(self, input):\n",
    "        # Formula from https://pytorch.org/docs/stable/generated/torch.nn.GELU.html\n",
    "        # This works identically to nn.GELU(approximate='tanh')\n",
    "        return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi) * (input + 0.044715 * torch.pow(input, 3))))\n",
    "```\n",
    "\n",
    "If we were to run this non-compiled/interpreted, we would only encounter e.g. `torch.pow` once we reached that line in the execution. Only then would we start to deploy a kernel to calculate the power of the input tensor. The 'effect of surprise' in the interpreted Python execution creates overhead.<br>\n",
    "\n",
    "GPUs, like CPUs, have cores that can execute multiple instructions in parallel. However, GPUs have a lot more cores than CPUs, optimized for parallel execution.<br>\n",
    "GPU cores also are simpler architectually, which makes them faster in executing the same instruction across multiple data points.<br>\n",
    "If we had known about the `torch.pow` operation in our `TanhGELU` beforehand, we could have compiled the model to have the GPU execute simple operation blocks in parallel.\n",
    "\n",
    "![](https://developer-blogs.nvidia.com/wp-content/uploads/2021/09/GPU-memory-oversubscription.png)<br>\n",
    "Source: [Improving GPU Memory Oversubscription Performance](https://developer.nvidia.com/blog/improving-gpu-memory-oversubscription-performance/)\n",
    "\n",
    "What's missing in this image are the caches. Both CPUs and GPUs have staged caches, which are much faster than High Bandwidth Memory (HBM) or main memory (RAM), but also much smaller.<br>\n",
    "Loading the right data at the right time to cache therefore is crucial for performance here. You can see the difference in speed between the memory types here:\n",
    "\n",
    "![](https://miro.medium.com/v2/resize:fit:500/format:webp/1*Diit8xd9fe27lZNM9jMW1Q.png)<br>\n",
    "Source: [ahmdtaha.medium.com](https://ahmdtaha.medium.com/flashattention-fast-and-memory-efficient-exact-attention-with-io-awareness-2a0aec52ed3d)\n",
    "\n",
    "Zoomed into the A100 GPU, we can actually see the L1- and L2-cache placements on the chip:\n",
    "\n",
    "![](https://miro.medium.com/v2/resize:fit:1500/format:webp/1*6xoBKi5kL2dZpivFe1-zgw.jpeg)<br>\n",
    "Source: [NVIDIA - A100 GPU Whitepaper (pp. 20, 22)](https://images.nvidia.com/aem-dam/en-zz/Solutions/data-center/nvidia-ampere-architecture-whitepaper.pdf) via [jonathan-hui.medium.com](https://jonathan-hui.medium.com/ai-chips-a100-gpu-with-nvidia-ampere-architecture-3034ed685e6e)\n",
    "\n",
    "For our example, specifically, we could have transfered the data for `torch.pow` to the GPU caches beforehand to be available in cache on time, where it would be easily accessible to the tensor cores.<br>\n",
    "The clou is that now we can pre-load it *and* have it stay there for as long as needed, because we use it multiple times afterwards during execution of the model,<br>\n",
    "e.g. for multiplication with scalar `0.044715`. This **prospective execution optimization** of the model is what PyTorch's `torch.compile` does for us.\n",
    "\n",
    "> `torch.compile` reduces overhead we otherwise would encounter through Python being an interpreted language. It allows us to place operations most fittingly into memory, *before* execution. No effect of surprise anymore, but benefit of hindsight instead."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### FlashAttention and a Caveat of Compilation\n",
    "\n",
    "There are some operations that are not supported by PyTorch's compiler as such.<br>\n",
    "One example is [Flash Attention \\[Dao et al. 2022\\]](https://arxiv.org/abs/2205.14135), which is a fundamental performance optimization for attention mechanisms.\n",
    "\n",
    "![](./images/flashattention_fused_kernel.png)<br>\n",
    "Source: [\\[Dao et al. 2022\\]](https://arxiv.org/abs/2205.14135)\n",
    "\n",
    "In `train_gpt2_1.py` and `train_gpt2_2.py`, we used this formulation within the forward pass of `CaustalSelfAttention`:\n",
    "\n",
    "```python\n",
    "att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))\n",
    "att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf'))\n",
    "att = F.softmax(att, dim=-1)\n",
    "y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)\n",
    "```\n",
    "\n",
    "Flash Attention argues that this stacked operation (first matmul, then mask, then softmax, then matmul again) can be algorithmically rewritten to a single fused operation, which is much faster.<br>\n",
    "Our `torch.compile()` does not perform this optimization on it's own though, because it requires some algorithmic adjustments.\n",
    "\n",
    "> The core idea in Flash Attention is to avoid GPU writes to HBM for the large `att` matrix (shape is `(B, nh, T, T)`).<br>\n",
    "> This is achieved by implementing the **online softmax trick** [\\[Milakov \\& Gimelshein 2018\\]](https://arxiv.org/abs/1805.02867).<br>\n",
    "> On its own, `torch.compile()` can't find this far-reaching of an optimization for memory usage.\n",
    "\n",
    "Now, in our current `train_gpt2_3.py`, we can implement this optimization manually as follows:\n",
    "    \n",
    "```python\n",
    "y = F.scaled_dot_product_attention(q, k, v, is_causal=True)\n",
    "```\n",
    "\n",
    "Without `torch.compile()`, just with Flash Attention, I get `dt: 40637.73ms, tok/sec: 403.17` on a 3060,<br>\n",
    "which actually starts to make this GPU look somewhat usable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing 'ugly' numbers\n",
    "\n",
    "In model training, there exist 'beautiful' and 'ugly' numbers.<br>\n",
    "For example, the number of sequences in a batch should be a multiple of $2$ as to make the most of the GPU's parallel processing capabilities.<br>\n",
    "In contrast, uneven numbers or prime numbers can kind of hinder downstream parallelization efforts.\n",
    "\n",
    "> Our optimization heuristic now is to remove 'ugly' numbers from our model training pipeline.\n",
    "\n",
    "I invite you to compare the numbers between the unoptimized `train_gpt2_2.py` and the now optimized `train_gpt2_3.py`.\n",
    "\n",
    "A really bad case of number ugliness is the `vocab_size` of `50257` in our model, as per official GPT-2 implementation.<br>\n",
    "This number is big and it's uneven. It's not a prime though, thankfully.<br>\n",
    "A nicer alternative would be `50304`. It can be divided by $8,\\ 16\\ 32$ and $128$.\n",
    "\n",
    "To update this value, we just update the `GPTConfig` dataclass in `train_gpt2_3.py` to this:\n",
    "\n",
    "```python\n",
    "@dataclass\n",
    "class GPTConfig:\n",
    "    block_size: int = 1024  # max sequence length\n",
    "    vocab_size: int = 50304 # number of tokens: 50,000 BPE merges + 256 bytes tokens + 1 <|endoftext|> token\n",
    "    n_layer: int = 12       # number of layers\n",
    "    n_head: int = 12        # number of heads\n",
    "    n_embd: int = 768       # embedding dimension\n",
    "```\n",
    "\n",
    "A 3060 without `torch.compile()` now gets `dt: 12998.15ms, tok/sec: 1260.49`.<br>\n",
    "Compare that to the initial `dt: 147900.74ms, tok/sec: 110.78`.<br>\n",
    "\n",
    "Still, we just introduced more tokens that we know for use will never be used, because we synthetically added them.<br>\n",
    "They can't be part of the vocabulary.\n",
    "\n",
    "This is ok in our case though, because we don't use most of the tokens in the vocabulary anyway with our small `Tiny-Shakespeare` dataset.<br>\n",
    "The dataset by design will note exhaust the vocabulary space that even `50257` tokens would provide.<br>\n",
    "So, making the `vocab_size` a 'nice' number out doesn't introduce any real headwind for us.\n",
    "\n",
    "Notice also that `torch.compile()` does not do this optimization for us either.<br>\n",
    "We need to do this manually as we see fit in the application context."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algorithmic Adaptations\n",
    "\n",
    "Depending on your setup, at this point, by running `train_gpt2_3.py` as it is now, you experience a flat out ~15x decrease in computation time compared to `train_gpt2_2.py` if setting `train_loader = DataLoaderLite(B=16, T=1024)` there. (I got `dt: 195892.37ms, tok/sec: 83.64` with the all unoptimized starter setup)<br>\n",
    "\n",
    "**I will stop working on `train_gpt2_3.py` at this point, so that it describes a solid intermediary step in our optimization process, i.e. what we did until now.<br>\n",
    "There are more optimizations to be done though, especially concerning algorithmic changes. These will be described in `train_gpt2_4.py` from here on.**\n",
    "\n",
    "Neither the [GPT-2 paper \\[Radford et al. 2018\\]](https://d4mucfpksywv.cloudfront.net/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) nor the [GPT-2 Repository](https://github.com/openai/gpt-2/blob/master/src/model.py) prove to be really informative about the detailed hyperparameter configuration.<br>\n",
    "Luckily the [GPT-3 paper \\[Brown et al. 2020\\]](https://arxiv.org/abs/2005.14165) is going more in-depth."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adam/AdamW Optimizer Configuration\n",
    "\n",
    "The first specification is the use of the `Adam` optimizer with $\\beta_1 = 0.9$, $\\beta_2 = 0.95$ and $\\epsilon = 10^{-8}$. We integrate that here:<br>\n",
    "```python\n",
    "optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4, betas=(0.9, 0.95), eps=1e-8)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Global Norm Clipping\n",
    "\n",
    "Next, we clip the global norm of the gradient at $1.0$ to have a 'maximium norm'.<br>\n",
    "This means that during training, gradients will be scaled down if their global norm (the square root of the sum of squares of all gradients) exceeds $1.0$,<br>\n",
    "effectively avoiding exploding gradients or individually large updates (e.g. due to individual 'unlucky' batches), overall stabilizing training.\n",
    "\n",
    "Like many of the optimizations until now, this boils down to one additonal line of code for our model:\n",
    "```python\n",
    "# Clipping the global norm at 1.0\n",
    "norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n",
    "```\n",
    "\n",
    "An initial epoch yields `step    0 | loss: 10.947495 | norm: 28.5703 | dt: 13934.98ms | tok/sec: 1175.75` now.<br>\n",
    "During training, the norm parameter will tend towards `0`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Learning Rate Decay\n",
    "\n",
    "GPT-2 and GPT-3 don't use a fixed learning rate like we do currently.<br>\n",
    "Instead, cosine-decay learning rate scheduling is applied so that after a specific amount of tokens was iterated over during ($260$ billion tokens), the learning rate decayed to only $10\\%$ of its starting value. Equally, there is a linear warm-up / ramp-up of the learning rate over the first $375$ million tokens in place.\n",
    "\n",
    "This is how the learning rate is adapted over time with the cosine-decay approach:\n",
    "\n",
    "![](https://miro.medium.com/v2/resize:fit:720/format:webp/1*BJCssPOCn4u__NoAZs392w.png)<br>\n",
    "Source: [scorrea92.medium.com](https://scorrea92.medium.com/cosine-learning-rate-decay-e8b50aa455b)\n",
    "\n",
    "The implementation looks something like this:\n",
    "```python\n",
    "max_lr = 6e-4 # According to GPT-3 paper\n",
    "min_lr = max_lr * 0.1\n",
    "warmup_steps = 10\n",
    "max_steps = 50\n",
    "\n",
    "def get_lr(it):\n",
    "    if it < warmup_steps:\n",
    "        # 1) Linear warmup region for warmup_iters steps\n",
    "        return max_lr * (it+1) / warmup_steps\n",
    "    if it > max_steps:\n",
    "        # 2) if it > lr_decay_iters, flat out return the min_lr\n",
    "        return min_lr\n",
    "    # 3) In between warmup and max_steps, cosine decay down to min_lr\n",
    "    decay_ratio = (it - warmup_steps) / (max_steps - warmup_steps)\n",
    "    assert 0 <= decay_ratio <= 1\n",
    "    coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) # coeff starts at 1 and goes to zero\n",
    "    return min_lr + coeff * (max_lr - min_lr)\n",
    "```\n",
    "\n",
    "We introduce that decaying learning rate into our training loop in a really interesting way, because we kind of override the old settings and inject it:\n",
    "```python\n",
    "for step in range(max_steps):\n",
    "    t0 = time.time()\n",
    "    x, y = train_loader.next_batch()\n",
    "    x, y = x.to(device), y.to(device)\n",
    "    optimizer.zero_grad()\n",
    "    with torch.autocast(device_type=device, dtype=torch.bfloat16):\n",
    "        logits, loss = model(x, y)\n",
    "    loss.backward()\n",
    "    norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) # Clipping the global norm at 1.0\n",
    "    # Determine and set the learning rate for this iteration step\n",
    "    lr = get_lr(step)\n",
    "    for param_group in optimizer.param_groups:\n",
    "        # Kind of side-injecting the actual learning rate we want to apply to the parameters here\n",
    "        param_group['lr'] = lr\n",
    "    optimizer.step()\n",
    "    torch.cuda.synchronize() # wait for GPU to finish above scheduled workload\n",
    "    t1 = time.time()\n",
    "    dt = (t1 - t0) # millisecond time difference\n",
    "    tokens_per_sec = (train_loader.B * train_loader.T) / (t1 - t0)\n",
    "    print(f\"step {step:4d} | loss: {loss.item():.6f} | lr: {lr:.4e} | norm: {norm:.4f} | dt: {dt*1000:.2f}ms | tok/sec: {tokens_per_sec:.2f}\")\n",
    "```\n",
    "\n",
    "My first step now looks like this: `step    0 | loss: 10.947495 | lr: 6.0000e-05 | norm: 28.5703 | dt: 12595.26ms | tok/sec: 1300.81`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dynamic Batch Size Increase\n",
    "\n",
    "In Appendix `B Details of Model Training` of [\\[Brown et al. 2020\\]](https://arxiv.org/abs/2005.14165), we can see that the batch sizes are increased in size as training progresses. This is done because in early stages of training, we roughly learn to 'use some tokens, disregard some others in the context we have right now'. This 'need/don't need' impact on the token relationships occurs for pretty much each example in the batch at this early stage, making their gradients at first look somewhat similar. Think of it as the inputs causing the model to perform a rough first sorting of what is needed and what isn't in terms of internal representations.\n",
    "\n",
    "Because this is the case early during training, we don't really require large batch sizes to be present just yet.<br>\n",
    "We don't really need this for our model, because this only really becomes relevant with vastly larger datasets. We'll skip that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Data Loading\n",
    "\n",
    "The [GPT-3 paper \\[Brown et al. 2020\\]](https://arxiv.org/abs/2005.14165) furthermore states this: \"Data are sampled without replacement during training (until an epcoh boundary is reached) to minimize overfitting.\"\n",
    "\n",
    "This means that from our training data, we draw and assemble a batch, have the model exposed to that batch, but then don't reuse the contents of this batch within this same epoch.<br>\n",
    "Lucky for us, we do that already, as can be seen by our `DataLoaderLite` moving with a sliding window step by step over the training set, asslembling batches without replacement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Weight Decay and Fused AdamW\n",
    "\n",
    "Finally, all models use a weight decay of $0.1$.<br>\n",
    "We will inject that notion into the creation of our `AdamW` optimizer by wrapping this creation process in a seperate function `configure_optimizers`:\n",
    "\n",
    "```python\t\n",
    "def configure_optimizers(self, weight_decay, learning_rate, device):\n",
    "        # start with all of the candidate parameters (that require grad)\n",
    "        param_dict = {pn: p for pn, p in self.named_parameters() if p.requires_grad}\n",
    "        # create optim groups. Any parameter that is 2D will be weight decayed, otherwise no.\n",
    "        # i.e. all weight tensors in matmuls + embeddings decay, but all biases and layernorms don't.\n",
    "        # Effectively splitting the parameters into two groups: decayable and non-decayable\n",
    "        decay_params = [p for n, p in param_dict.items() if p.dim() >= 2]\n",
    "        # 1D tensors (layer norms, biases) are not decayed\n",
    "        nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2]\n",
    "        optim_groups = [\n",
    "            {\"params\": decay_params, \"weight_decay\": weight_decay},\n",
    "            {\"params\": nodecay_params, \"weight_decay\": 0.0},\n",
    "        ]\n",
    "        num_decay_params = sum(p.numel() for p in decay_params)\n",
    "        num_nodecay_params = sum(p.numel() for p in nodecay_params)\n",
    "        print(f\"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params} parameters\")\n",
    "        print(f\"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params} parameters\")\n",
    "        # Create AdamW optimizer and use the fused version if it is available\n",
    "        # Essentially checking here if the option 'fused' is available in the AdamW optimizer (depends on PyTorch version)\n",
    "        fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters\n",
    "        use_fused = fused_available and 'cuda' in device\n",
    "        print(f\"using fused AdamW: {use_fused}\")\n",
    "        optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=(0.9, 0.95), eps=1e-8, fused=use_fused)\n",
    "        return optimizer\n",
    "```\n",
    "\n",
    "Pulling down all the weights enforces a distributed use of (all) weights, which is good for generalization.<br>\n",
    "The `fused` parameter is kind of interesting: Instead of iterating the optimizer over all the parameters, updating them one by one, a single kernel is deployed to update all parameters at once.<br>\n",
    "This is a significant speed-up, especially for large models.\n",
    "\n",
    "We inject that into our actual training process by replacing our vanilla `AdamW` initialization with the `configure_optimizers` function call:\n",
    "\n",
    "```python\n",
    "optimizer = model.configure_optimizers(weight_decay=0.1, learning_rate=max_lr, device=device)\n",
    "```\n",
    "\n",
    "This outputs:<br>\n",
    "`num decayed parameter tensors: 50, with 124354560 parameters`<br> \n",
    "`num non-decayed parameter tensors: 98, with 121344 parameters`\n",
    "\n",
    "`fused` works only on certain CUDA devices. Use it if you can."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Gradient Accumulation for Simulating Large Batch Sizes\n",
    "\n",
    "Let's have a look again at the sizes, architectures and learning hyperparameters for GPT-3 (and GPT-2):\n",
    "\n",
    "![](./images/gpt3_train_table.png)<br>\n",
    "Source: [\\[Brown et al. 2020\\]](https://arxiv.org/abs/2005.14165)\n",
    "\n",
    "One thing we can not reproduce here is the original batch size of $500,000$ tokens.<br>\n",
    "We currently have $16$ sequences $\\times 1024$ tokens per batch.<br>\n",
    "If we were to maintain this context size, we would need $\\frac{500,000}{1024}\\approx 488$ sequences per batch.<br>\n",
    "I don't know about your setup, but my 3060 would preemtively disintegrate if I just tried to do that.\n",
    "\n",
    "The thing is that this batch size of $500,000$ tokens is correlated with e.g. the learning rate, the number of layers, the embedding size etc.<br>\n",
    "As crazy as it might sound at this point, we actually want to somehow use this huge batch size, just because it brings out the best in the model training in correlation with the other hyperparameters we already use (as per OpenAI's setup at least).\n",
    "\n",
    "We can apply a trick for this. It's called **gradient accumulation**.\n",
    "\n",
    "Through Gradient accumulation we can sum up gradients recovered over multiple batches before actually updating the model weights.<br>\n",
    "This allows us to 'simulate' larger batches and enables training with more efficient use of GPU memory.\n",
    "\n",
    "Introducing this into our `traing_gpt2_4.py` requires us to restructure `train_loader = DataLoaderLite(B=16, T=1024)`.\n",
    "\n",
    "As a first change, we introduce the `grad_accum_steps` parameter into our training setup:\n",
    "\n",
    "```python\n",
    "total_batch_size = 524288 # 2**19, ~0.5M tokens, as per GPT-3 paper\n",
    "# Doing 16384 tokens per micro-batch \n",
    "# -> 32 micro-batches to accumulate into a full batch\n",
    "B = 16 # micro-batch size\n",
    "T = 1024 # sequence length\n",
    "assert total_batch_size % (B * T) == 0, \"Batch size must be divisible by (micro-batch size * sequence length).\"\n",
    "# Accumulate gradients over grad_accum_steps instead of backpropagating each step\n",
    "grad_accum_steps = total_batch_size // (B * T) # 32\n",
    "print(f\"Total desired batch size: {total_batch_size}\")\n",
    "print(f\"-> Calculated gradient accumulation steps: {grad_accum_steps}\")\n",
    "\n",
    "# DataLoaderLite for micro-batched training data\n",
    "train_loader = DataLoaderLite(B=T, T=B)\n",
    "```\n",
    "\n",
    "Notice how we still use the `DataLoaderLite`, but now for the micro-batches of size $16 \\times 1024$ tokens.<br>\n",
    "We accumulate gradients over $32$ micro-batches, effectively summing up gradients over $524288$ tokens before updating the model weights.<br>\n",
    "We didn't implement this part yet, though. This is done in the training loop itself:\n",
    "\n",
    "```python\n",
    "for step in range(max_steps):\n",
    "    t0 = time.time()\n",
    "    optimizer.zero_grad() # Reset gradients per macro-batch\n",
    "    # Inner loop across micro-batches\n",
    "    for micro_step in range(grad_accum_steps):\n",
    "        x, y = train_loader.next_batch()\n",
    "        x, y = x.to(device), y.to(device)\n",
    "        with torch.autocast(device_type=device, dtype=torch.bfloat16):\n",
    "            logits, loss = model(x, y)\n",
    "        # This accumulates now, because we don't call zero_grad() in the inner loop\n",
    "        loss.backward()\n",
    "    norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) # Clipping the global norm at 1.0\n",
    "    # Determine and set the learning rate for this iteration step\n",
    "    lr = get_lr(step)\n",
    "    for param_group in optimizer.param_groups:\n",
    "        # Kind of side-injecting the actual learning rate we want to apply to the parameters here\n",
    "        param_group['lr'] = lr\n",
    "    optimizer.step()\n",
    "    torch.cuda.synchronize() # wait for GPU to finish above scheduled workload\n",
    "    t1 = time.time()\n",
    "    dt = (t1 - t0) # millisecond time difference\n",
    "    tokens_processed = train_loader.B * train_loader.T\n",
    "    tokens_per_sec = (train_loader.B * train_loader.T) / (t1 - t0)\n",
    "    print(f\"step {step:4d} | loss: {loss.item():.6f} | lr: {lr:.4e} | norm: {norm:.4f} | dt: {dt*1000:.2f}ms | tok/sec: {tokens_per_sec:.2f}\")  \n",
    "```\n",
    "\n",
    "Looks good? Well, it's buggy!<br>\n",
    "The problem we have with this is subtle, but it's significant.<br>\n",
    "The loss calcuation is now based on the sum of the losses over the micro-batches.<br>\n",
    "This is not what we want, because each micro-batch loss gets scaled by the number of tokens in the micro-batch.\n",
    "\n",
    "If we were to just sum these 'micro-batch-wise meaned' losses up, then the resulting sum would not represent the correct loss as would be calculated over the full batch.<br>\n",
    "\n",
    "Let's see this with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-0.0150,  0.0011,  0.0042, -0.0040,  0.0059, -0.0080, -0.0078, -0.0138,\n",
      "        -0.0103, -0.0134])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "net = torch.nn.Sequential(\n",
    "    torch.nn.Linear(16, 32),\n",
    "    torch.nn.GELU(),\n",
    "    torch.nn.Linear(32, 1)\n",
    ")\n",
    "\n",
    "torch.random.manual_seed(42)\n",
    "\n",
    "x = torch.randn(4, 16)  # 4 samples, 16 features\n",
    "y = torch.randn(4, 1)   # 4 samples, 1 target\n",
    "net.zero_grad()\n",
    "y_hat = net(x)\n",
    "loss = torch.nn.functional.mse_loss(y_hat, y)\n",
    "loss.backward()\n",
    "# Show the first 10 gradients as example\n",
    "grads_macro = net[0].weight.grad.view(-1)[:10]\n",
    "print(grads_macro)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Effectively, the above code performs this $\\text{MSE}$ loss calculation:\n",
    "$$\\text{Loss} = \\frac{1}{4}\\times \\left[ (y_0 - \\hat{y}_0)^2 + (y_1 - \\hat{y}_1)^2 + (y_2 - \\hat{y}_2)^2 + (y_3 - \\hat{y}_3)^2 \\right]$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the next snippet shows what we effectively implemented above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-0.0598,  0.0042,  0.0167, -0.0161,  0.0235, -0.0320, -0.0311, -0.0550,\n",
      "        -0.0410, -0.0536])\n",
      "\n",
      "Gradients are identical: False\n"
     ]
    }
   ],
   "source": [
    "net.zero_grad()\n",
    "for i in range(x.shape[0]):\n",
    "    # Forward ONLY one sample micro-batch at a time\n",
    "    y_hat = net(x[i])\n",
    "    # Compute loss per each micro-batch\n",
    "    loss = torch.nn.functional.mse_loss(y_hat, y[i])\n",
    "    loss.backward()\n",
    "\n",
    "# Show the first 10 gradients as example\n",
    "grads_micro = net[0].weight.grad.view(-1)[:10]\n",
    "print(grads_micro)\n",
    "print(f\"\\nGradients are identical: {torch.allclose(grads_macro, grads_micro)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The problem is that this code acually calculates the loss as:\n",
    "$$\\text{Loss} = \\frac{1}{1}\\times \\left[ (y_0 - \\hat{y}_0)^2 \\right] + \\frac{1}{1}\\times \\left[ (y_1 - \\hat{y}_1)^2 \\right] + \\frac{1}{1}\\times \\left[ (y_2 - \\hat{y}_2)^2 \\right] + \\frac{1}{1}\\times \\left[ (y_3 - \\hat{y}_3)^2 \\right]$$\n",
    "\n",
    "> By default, plainly summing the micro-batch losses is not identical to the loss calculated over a full batch.\n",
    "\n",
    "We can resolve this behavior like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-0.0150,  0.0011,  0.0042, -0.0040,  0.0059, -0.0080, -0.0078, -0.0138,\n",
      "        -0.0103, -0.0134])\n",
      "\n",
      "Gradients are identical: True\n"
     ]
    }
   ],
   "source": [
    "net.zero_grad()\n",
    "\n",
    "for i in range(x.shape[0]):\n",
    "    # Forward ONLY one sample micro-batch at a time\n",
    "    y_hat = net(x[i])\n",
    "    # Compute loss per each micro-batch\n",
    "    loss = torch.nn.functional.mse_loss(y_hat, y[i])\n",
    "    \n",
    "    # NEW: Scale the loss down, \n",
    "    # normalize loss by relation of micro-batch size [this is an incomplete explanation, see below]\n",
    "    loss = loss / x.shape[0]\n",
    "\n",
    "    loss.backward()\n",
    "\n",
    "# Show the first 10 gradients as example\n",
    "grads_micro = net[0].weight.grad.view(-1)[:10]\n",
    "print(grads_micro)\n",
    "print(f\"\\nGradients are identical: {torch.allclose(grads_macro, grads_micro)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We find that:\n",
    "> Micro-Batching requires us to scale the loss according to the contribution of the micro-batch to the full batch.<br>\n",
    "> This is done by normalizing the micro-batch loss by `(macro-batch size / micro-batch size)`.\n",
    "\n",
    "The above explanation maybe leaves us not too sure about this.<br>\n",
    "The relationship between micro-batch and macro-batch becomes obvious when we look at another example,<br>\n",
    "this time with a batch size of $2$ instead of $1$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([-0.0075,  0.0005,  0.0021, -0.0020,  0.0029, -0.0040, -0.0039, -0.0069,\n",
      "        -0.0051, -0.0067])\n",
      "\n",
      "Gradients are identical: False\n",
      "\n",
      "\n",
      "tensor([-0.0150,  0.0011,  0.0042, -0.0040,  0.0059, -0.0080, -0.0078, -0.0138,\n",
      "        -0.0103, -0.0134])\n",
      "\n",
      "Gradients are identical: True\n"
     ]
    }
   ],
   "source": [
    "net.zero_grad()\n",
    "\n",
    "micro_batch_size = 2\n",
    "\n",
    "# Run with old configuration\n",
    "for i in range(0, x.shape[0], micro_batch_size):\n",
    "    # Forward pass for each micro-batch\n",
    "    y_hat = net(x[i:i + micro_batch_size])\n",
    "    # Compute loss for the micro-batch\n",
    "    loss = torch.nn.functional.mse_loss(y_hat, y[i:i + micro_batch_size])\n",
    "    # Normalize loss by micro-batch size [this would be identical to the above approach, but its incomplete]\n",
    "    loss = loss / (x.shape[0]) # Just normalizing by full batch size will not suffice\n",
    "    # Backward pass\n",
    "    loss.backward()\n",
    "\n",
    "# Show the first 10 gradients as example\n",
    "grads_micro = net[0].weight.grad.view(-1)[:10]\n",
    "print(grads_micro)\n",
    "print(f\"\\nGradients are identical: {torch.allclose(grads_macro, grads_micro)}\\n\\n\")\n",
    "\n",
    "net.zero_grad()\n",
    "\n",
    "# Run with new configuration\n",
    "for i in range(0, x.shape[0], micro_batch_size):\n",
    "    # Forward pass for each micro-batch\n",
    "    y_hat = net(x[i:i + micro_batch_size])\n",
    "    # Compute loss for the micro-batch\n",
    "    loss = torch.nn.functional.mse_loss(y_hat, y[i:i + micro_batch_size])\n",
    "    # Normalize loss by relation of full batch size to micro-batch size [!!!]\n",
    "    loss = loss / (x.shape[0] / micro_batch_size)\n",
    "    # Backward pass\n",
    "    loss.backward()\n",
    "\n",
    "# Show the first 10 gradients as example\n",
    "grads_micro = net[0].weight.grad.view(-1)[:10]\n",
    "print(grads_micro)\n",
    "print(f\"\\nGradients are identical: {torch.allclose(grads_macro, grads_micro)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We carefully need to normalize the micro-batch loss by the relation of full batch size to micro-batch size.\n",
    "\n",
    "If we implement that into our `GPT` class, we get this change in the optimization loop's inner loop:\n",
    "\n",
    "```python\n",
    "# Optimization loop\n",
    "for step in range(max_steps):\n",
    "    t0 = time.time()\n",
    "    optimizer.zero_grad() # Reset gradients per macro-batch\n",
    "    loss_accum = 0.0 # Loss accumulator over the micro-batches\n",
    "    # Inner loop across micro-batches\n",
    "    for micro_step in range(grad_accum_steps):\n",
    "        x, y = train_loader.next_batch() # (B, T)\n",
    "        x, y = x.to(device), y.to(device)\n",
    "        with torch.autocast(device_type=device, dtype=torch.bfloat16):\n",
    "            logits, loss = model(x, y)\n",
    "        # Normalize micro-batch loss by relation of full batch size to micro-batch size\n",
    "        loss = loss / grad_accum_steps\n",
    "        loss_accum += loss.detach()\n",
    "        # This accumulates now, because we don't call zero_grad() in the inner loop\n",
    "        loss.backward()\n",
    "    norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) # Clipping the global norm at 1.0\n",
    "    # Determine and set the learning rate for this iteration step\n",
    "    lr = get_lr(step)\n",
    "    for param_group in optimizer.param_groups:\n",
    "        # Kind of side-injecting the actual learning rate we want to apply to the parameters here\n",
    "        param_group['lr'] = lr\n",
    "    optimizer.step()\n",
    "    torch.cuda.synchronize() # wait for GPU to finish above scheduled workload\n",
    "    t1 = time.time()\n",
    "    dt = (t1 - t0) # millisecond time difference\n",
    "    tokens_processed = train_loader.B * train_loader.T * grad_accum_steps # Tokens processed per step\n",
    "    tokens_per_sec = (train_loader.B * train_loader.T) / (t1 - t0)\n",
    "    print(f\"step {step:4d} | loss: {loss_accum.item():.6f} | lr: {lr:.4e} | norm: {norm:.4f} | dt: {dt*1000:.2f}ms | tok/sec: {tokens_per_sec:.2f}\") \n",
    "```\n",
    "<br>\n",
    "\n",
    "**Why do we normalize only by `grad_accum_steps` and not by some expression `(total_batch_size / mini_batch_size)` like above?**\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "Actually, we do just that. The `grad_accum_steps` sufficiently expresses this relationship, which is \n",
    "$$\\frac{\\text{grad\\_accum\\_steps} \\times B \\times T}{B \\times T} = \\text{grad\\_accum\\_steps}$$\n",
    "\n",
    "**One more thing:** Above I copied over the entire optimization loop because there is also a change in the `tokens_processed` calculation.<br>\n",
    "Now we additionally account for the `grad_accum_steps` in the calculation of the tokens processed per step, effectively incorporating the face we use micro-batching into the calculation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can train our model!<br>\n",
    "If you want to try training this, but you only have a small CUDA device, you can reduce the micro-batch size to e.g. $8$ or $4$ sequences.<br>\n",
    "Just changing that parameter at its initialization suffices, everything else is done automatically.\n",
    "\n",
    "I did a test run with the 3060 and set `B = 8`, which made training take ~$1$ hour for $50$ steps.<br>\n",
    "For example, at step $5$ I got: `step    5 | loss: 8.609741 | lr: 3.6000e-04 | norm: 3.0927 | dt: 56625.14ms | tok/sec: 144.67`.<br>\n",
    "At step $49$ I got: `step   49 | loss: 5.558484 | lr: 6.0832e-05 | norm: 0.2166 | dt: 50348.39ms | tok/sec: 156.45`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training on Multiple GPUs\n",
    "\n",
    "We optimized the code for our GPT-2 clone a lot already. Specifically, we performed optimizations through PyTorch's settings, through algorithmic optimizations, e.g. the learning rate decay, weight decay and gradient norm clipping, the `AdamW` optimizer configuration and the `DataLoaderLite` implementation with gradient accumulation.<br>\n",
    "\n",
    "**That's a lot.** We really made the code more efficient and faster.<br>\n",
    "Because we did that, we can now consider training on multiple GPUs.<br>\n",
    "It would be far too expensive to do so without optimizations already in place.\n",
    "\n",
    "Let's get out the heavy guns and setup training on multiple GPUs using `DistributedDataParallel`.\n",
    "\n",
    "**All the code for this evolution of our training script can be found in `train_gpt2_5.py`.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Introducing DistributedDataParallel\n",
    "\n",
    "The idea behind `DistributedDataParallel` is to split the model across as many training processes as there are GPUs, so that each GPU processes a part of the model.<br>\n",
    "Then, the gradients are collected and averaged across all GPUs, and the model weights are updated accordingly.<br>\n",
    "This training job will be kicked-off through `torchrun`.\n",
    "\n",
    "The par that is new in the `train_gpt2_5.py` script is this setup code:\n",
    "```python\n",
    "# Set up the DDP (distributed data parallel) environment\n",
    "ddp = int(os.environ.get('RANK', -1)) != -1 # check if we are in a DDP environment/run\n",
    "if ddp:\n",
    "    # use of DDP atm demands CUDA, we set the device appropriately according to rank\n",
    "    assert torch.cuda.is_available(), \"DDP requires CUDA for now - please run on a GPU node.\"\n",
    "    init_process_group(backend='nccl')  # initialize distributed backend\n",
    "    ddp_rank = int(os.environ['RANK'])  # rank of current process\n",
    "    ddp_local_rank = int(os.environ['LOCAL_RANK'])  # local rank/GPU index of current process\n",
    "    # (ddp_local_rank means within the node, ddp_rank is global, meaning across all nodes; node: machine with multiple GPUs (just saying))\n",
    "    ddp_world_size = int(os.environ['WORLD_SIZE'])  # number of processes in the DDP environment\n",
    "    device = f\"cuda:{ddp_local_rank}\"  # map the device according to the local rank (indicates which GPU to use on the node)\n",
    "    torch.cuda.set_device(device)      # set the device to the local rank\n",
    "    master_process = ddp_rank == 0     # check if current process is master (master does logging, checkpointing etc.)\n",
    "else:\n",
    "    # vanilla, non-DDP run\n",
    "    ddp_rank = 0\n",
    "    ddp_local_rank = 0\n",
    "    ddp_world_size = 1\n",
    "    master_process = True\n",
    "\n",
    "    # Find the best available device to train on\n",
    "    device = \"cpu\"\n",
    "    if torch.cuda.is_available():\n",
    "        device = \"cuda\" # NVIDIA GPU\n",
    "    elif hasattr(torch.backends, \"mps\") and torch.backends.mps.is_initialized():\n",
    "        device = \"mps\" # Apple Silicon\n",
    "    print(f\"Using device: {device}\")\n",
    "```\n",
    "\n",
    "To us this might look a bit odd, as this is really the only change in the script (for now). But, if run with `torchrun`, this script will be executed on multiple GPUs as per this setup.<br>\n",
    "`LOCAL_RANK` refers to the GPU index on the node, `RANK` is the global rank across all nodes, and `WORLD_SIZE` is the total number of processes in the DDP environment we want to run.<br>\n",
    "\n",
    "If you have you, as one does, have `8` GPUs available, this part of the script will be read by each of the `8` processes, and each process will be assigned a different `LOCAL_RANK` from `0` to `7`.<br>\n",
    "As this code snippet passed through, the rest of the training code will be read by each process as well.<br>\n",
    "We don't want each process to execute the full training code though.<br>\n",
    "Therefore, we now have to adapt our training code to be (most evenly) distributable across multiple GPUs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adapting the Gradient Accumulation\n",
    "\n",
    "The first few changes are performed with regard to the micro-batching:\n",
    "\n",
    "```python\n",
    "total_batch_size = 524288 # still the same\n",
    "B = 16 # still the same\n",
    "T = 1024 # still the same\n",
    "assert total_batch_size % (B * T * ddp_world_size) == 0, \"Batch size must be divisible by (micro-batch size * sequence length * ddp_world_size).\"\n",
    "# Accumulate gradients over grad_accum_steps instead of backpropagating each step\n",
    "# Each process does B * T, and there are ddp_world_size many processes\n",
    "# E.g. on 8 GPUs, we will now learn on 16 * 1024 * [8] = 131072 tokens per step before backpropagating\n",
    "grad_accum_steps = total_batch_size // (B * T * ddp_world_size)\n",
    "```\n",
    "\n",
    "If we want parallelism, then in the same time we aim to process more. The factor by which we want to process more is the number of GPUs we have available, which is `ddp_world_size` in our case.<br>\n",
    "Therefore we adapt our `grad_accum_steps` to to accumulate what our `8` GPUs can process in parallel, which is `B * T` tokens per GPU.\n",
    "\n",
    "> Because we parallelize, we can process more in the same time. This is why we can increase the number of tokens processed per step, which actually brings down the number of micro-batches we need to process to cover one full batch."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adapting the DataLoader\n",
    "\n",
    "Next up, we need to make the `DataLoaderLite` aware of the distributed setup. Specifically, not every process should load the same data.<br>\n",
    "Every process should work on its own datasubset. The solution for this is kind of neat:\n",
    "\n",
    "```python\n",
    "class DataLoaderLite:\n",
    "    def __init__(self, B, T, process_rank, num_processes):\n",
    "        self.B = B # batch size\n",
    "        self.T = T # context size\n",
    "        self.process_rank = process_rank # rank of the current process\n",
    "        self.num_processes = num_processes # total number of processes\n",
    "\n",
    "        # at init load tokens from disk and store them in memory\n",
    "        with open('../tiny-shakespeare.txt', 'r') as f:\n",
    "            text = f.read()\n",
    "        enc = tiktoken.get_encoding('gpt2')\n",
    "        tokens = enc.encode(text) # encode full text into tokens\n",
    "        self.tokens = torch.tensor(tokens) # wrap with tensor\n",
    "        # Just some stats for us nerds\n",
    "        print(f\"loaded {len(self.tokens)} tokens\")\n",
    "        print(f\"1 epoch = {len(self.tokens) // (B * T)} batches\")\n",
    "\n",
    "        # token-level start position for each next batch\n",
    "        # NEW: This changes in relation to the process rank now, as to stride out processes across the data\n",
    "        self.current_position = self.B * self.T * self.process_rank # Process 0 starts at 0, Process 1 at (next batch) B*T, etc.\n",
    "\n",
    "    def next_batch(self):\n",
    "        B, T = self.B, self.T\n",
    "        # grab a chunk of tokens of size B * T + 1 (we explained this before)\n",
    "        buf = self.tokens[self.current_position:self.current_position + B * T + 1]\n",
    "        x = buf[:-1].view(B, T) # input tensor of size (B * T)\n",
    "        y = buf[1:].view(B, T)  # target tensor of size (B * T), right-shifted 1 position\n",
    "        # advance position in data tensor\n",
    "        # NEW: Jump to the next batch, taking into account the number of processes\n",
    "        self.current_position += B * T * self.num_processes\n",
    "        # if loading the next batch would be out of bounds, reset\n",
    "        # NEW: Check if our parallel-process-aware jump would be out of bounds\n",
    "        if self.current_position + (B * T * self.num_processes + 1) >= len(self.tokens):\n",
    "            # reset position to beginning of data, w.r.t. process rank\n",
    "            self.current_position = self.B * self.T * self.process_rank\n",
    "        return x, y\n",
    "```\n",
    "(see the parts commented with `NEW`)\n",
    "\n",
    "We now additionally pass the `process_rank` of the caller and the `num_processes` for a picture of the process landscape to the `DataLoaderLite` constructor.<br>\n",
    "Per each process, we then start iterating over the dataset by a batch offset determined by the `process_rank`, resulting in `self.current_position = self.B * self.T * self.process_rank`.<br>\n",
    "Also, each process now has to advance differently through the dataset. We solve that here by having each process 'jump' to a next batch by `self.current_position += B * T * self.num_processes`.<br>\n",
    "The processes in parallel now hop through the dataset to specifically assigned subsets of the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fully Integrating DistributedDataParallel\n",
    "\n",
    "One thing that's still missing is the capability of inter-process communication to average the gradients.<br>\n",
    "We can do this quite swiftly by wrapping the model in `DistributedDataParallel`:\n",
    "\n",
    "```python\n",
    "model = GPT(GPTConfig()) # random weight initialization\n",
    "model.to(device)\n",
    "\n",
    "# Check if we run on Linux:\n",
    "if os.name == 'posix' and sys.platform != 'darwin':\n",
    "    model = torch.compile(model) # compile model to TorchScript -> speed + memory savings\n",
    "\n",
    "if ddp:\n",
    "    # Once each GPUs backward is over, DDP will average the gradients across all GPUs\n",
    "    model = DDP(model, device_ids=[ddp_local_rank])\n",
    "```\n",
    "\n",
    "We wrap the model in `DDP` if we are in a distributed setup. The `device_ids` parameter is set to the `ddp_local_rank` of the process, which is the GPU index on the node.<br>\n",
    "This is the only change we need to make to our model training setup to make it distributed. Inter-process communication is handled by `DDP` under the hood."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Distributing the Training Loop\n",
    "\n",
    "Currently, due to micro-batching, we perform a scaled `loss.backward()` call for every micro-batch.<br>\n",
    "This is fine, but we don't want to sync the gradients across all GPUs after every single micro-batch.<br>\n",
    "Instead we want to sync the gradients after the full batch was processed, i.e. after a last micro-batch was processed making up this full batch.\n",
    "\n",
    "Here's the full updated training loop. Buckle up:\n",
    "\n",
    "```python\n",
    "# Optimization loop\n",
    "for step in range(max_steps):\n",
    "    t0 = time.time()\n",
    "    optimizer.zero_grad() # Reset gradients per macro-batch\n",
    "    loss_accum = 0.0 # Loss accumulator over the micro-batches\n",
    "    # Inner loop across micro-batches\n",
    "    for micro_step in range(grad_accum_steps):\n",
    "        x, y = train_loader.next_batch() # (B, T)\n",
    "        x, y = x.to(device), y.to(device)\n",
    "        with torch.autocast(device_type=device, dtype=torch.bfloat16):\n",
    "            logits, loss = model(x, y)\n",
    "        # Normalize micro-batch loss by relation of full batch size to micro-batch size\n",
    "        loss = loss / grad_accum_steps\n",
    "        loss_accum += loss.detach()\n",
    "        if ddp:\n",
    "            # DDP will take care of averaging the loss across all GPUs\n",
    "            # DDP will do so only after the last micro-batch in each accumulation cycle\n",
    "            model.require_backward_grad_sync = (micro_step == grad_accum_steps - 1)\n",
    "        # This accumulates now, because we don't call zero_grad() in the inner loop\n",
    "        loss.backward()\n",
    "    if ddp:\n",
    "        # Average the macro-batch loss across all GPUs, \n",
    "        # after having done that, synchronize this average loss to be the same value set across all GPUs\n",
    "        dist.all_reduce(loss_accum, op=dist.ReduceOp.AVG)\n",
    "    norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) # Clipping the global norm at 1.0\n",
    "    # Determine and set the learning rate for this iteration step\n",
    "    lr = get_lr(step)\n",
    "    for param_group in optimizer.param_groups:\n",
    "        # Kind of side-injecting the actual learning rate we want to apply to the parameters here\n",
    "        param_group['lr'] = lr\n",
    "    optimizer.step()\n",
    "    torch.cuda.synchronize() # wait for GPU to finish above scheduled workload\n",
    "    t1 = time.time()\n",
    "    dt = (t1 - t0) # millisecond time difference\n",
    "    tokens_processed = train_loader.B * train_loader.T * grad_accum_steps * ddp_world_size # Tokens processed per step across all GPUs\n",
    "    tokens_per_sec = tokens_processed / dt\n",
    "    if master_process:\n",
    "        print(f\"step {step:4d} | loss: {loss_accum.item():.6f} | lr: {lr:.4e} | norm: {norm:.4f} | dt: {dt*1000:.2f}ms | tok/sec: {tokens_per_sec:.2f}\")      \n",
    "\n",
    "if ddp:\n",
    "    destroy_process_group() # DDP cleanup\n",
    "```\n",
    "\n",
    "By calling `model.require_backward_grad_sync = (micro_step == grad_accum_steps - 1)`, we essentially wait until we processed the last micro-batch in the accumulation cycle before we sync the gradients (that make up the gradients for the macro-batch) across all GPUs.<br>\n",
    "Then, to have an idea of the disttributed model's performance, we average the accumulated loss `loss_accum` (meaning the indicator for the loss of the full batch) across all GPUs using `dist.all_reduce(loss_accum, op=dist.ReduceOp.AVG)`.<br>\n",
    "We then show this average as a performance indicator via the master process.<br>\n",
    "Finally, for good measure, we clean up the DDP environment after training."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we now want to see this setup in action, we shouldn't run `python train_gpt2_5.py`, but `torchrun --standalone --nproc_per_node=8 train_gpt2_5.py` if we have `8` GPUs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## We Definitely Need More Data\n",
    "\n",
    "Now that our training setup can actually pack a punch, we should really consider training on more data.<br>\n",
    "More so, we should really increase the dataset beyond our tiny Shakespeare text to avoid overfitting and to make the model more general.\n",
    "\n",
    "According to the [GPT-2 paper \\[Radford et al. 2018\\]](https://d4mucfpksywv.cloudfront.net/better-language-models/language_models_are_unsupervised_multitask_learners.pdf), the GPT-2 model was trained on data scraped from links going out from Reddit, where the link was rewarded with at least $3$ upvotes.<br>\n",
    "This amounted to a dataset of $40$GB of text data.\n",
    "\n",
    "The [GPT-3 paper \\[Brown et al. 2020\\]](https://arxiv.org/abs/2005.14165) states that the GPT-3 model was trained on a dataset of $570$GB of text data assembled using Common Crawl, which is a web crawler.\n",
    "\n",
    "More specifically, the GPT-3 training dataset was made up of the following sources:\n",
    "\n",
    "![GPT-3 Training Data Sources](./images/gpt3_training_data_sources.png)<br>\n",
    "Source: [\\[Brown et al. 2020\\]](https://arxiv.org/abs/2005.14165)\n",
    "\n",
    "Note that this dataset was never publicly released. But there are publicly available alternatives like [SlimPajama](https://www.cerebras.net/blog/slimpajama-a-627b-token-cleaned-and-deduplicated-version-of-redpajama), [FineWeb](https://huggingfacefw-blogpost-fineweb-v1.static.hf.space/dist/index.html) or [FineWeb-EDU](https://huggingface.co/datasets/HuggingFaceFW/fineweb-edu). \n",
    "\n",
    "We will use the `FineWeb-EDU` dataset for our training.<br>\n",
    "Specifically, we will use the `sample-10BT` subset of the full dataset.\n",
    "\n",
    "We will download the dataset and preprocess it for training through the script `fineweb.py`.<br>\n",
    "We will need a folder `./edu_fineweb10B` for that. There, numpy data shards will be created.<br>\n",
    "The first shard, `edufineweb_val_000000.npy` will hold the validation set.<br>\n",
    "The other shards will have names like `edufineweb_train_000001.npy` etc.\n",
    "\n",
    "In total, you should get $100$ data shards."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DataLoader Adjustments\n",
    "\n",
    "Our `DataLoaderLite` will need to be adjusted to load the data shards instead of the Shakespeare text.<br>\n",
    "I will not paste the adaptations here because logically the processing has not really changed.<br>\n",
    "It was just adapted to shard-based data loading.<br>\n",
    "You can of course still find it in `train_gpt2-5.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eval, Logging and Visualization\n",
    "\n",
    "While our script works very well now, we don't yet perform any logging, eval or visualization.<br>\n",
    "Let's start with including evaluation on the validation set.\n",
    "\n",
    "For evaluation, we create a seperate `val_loader` instance of the `DataLoaderLite` class, which will load the validation data shards.<br>\n",
    "Then, every $100$ macro-batches, we evaluate the model on some amount of steps of the validation set and print the accumulated validation loss.\n",
    "\n",
    "This is what we inject into the training loop:\n",
    "\n",
    "```python\n",
    "# Optimization loop\n",
    "for step in range(max_steps):\n",
    "    t0 = time.time()\n",
    "\n",
    "    # once in a while, check on the validation set\n",
    "    if step % 100 == 0:\n",
    "        model.eval()\n",
    "        val_loader.reset()\n",
    "        with torch.no_grad():\n",
    "            val_loss_accum = 0.0\n",
    "            val_loss_steps = 20\n",
    "            for _ in range(val_loss_steps):\n",
    "                x, y = val_loader.next_batch()\n",
    "                x, y = x.to(device), y.to(device)\n",
    "                with torch.autocast(device_type=device, dtype=torch.bfloat16):\n",
    "                    logits, loss = model(x, y)\n",
    "                loss = loss / grad_accum_steps\n",
    "                val_loss_accum += loss.detach()\n",
    "        if ddp:\n",
    "            dist.all_reduce(val_loss_accum, op=dist.ReduceOp.AVG)\n",
    "        if master_process:\n",
    "            print(f\"validation loss: {val_loss_accum.item():.6f}\")\n",
    "    # [...]\n",
    "```\n",
    "\n",
    "Also on every 100th step except the very first, we *finally* show some sample text generated by the model at that point in training.<br>\n",
    "\n",
    "```python\n",
    "    # [the ... from above]\n",
    "    if step > 0 and step % 100 == 0:\n",
    "        model.eval()\n",
    "        num_return_sequences = 4\n",
    "        max_length = 32\n",
    "        tokens = enc.encode(\"Hello, I'm a language model,\")\n",
    "        tokens = torch.tensor(tokens, dtype=torch.long)\n",
    "        tokens = tokens.unsqueeze(0).repeat(num_return_sequences, 1)\n",
    "        xgen = tokens.to(device)\n",
    "        sample_rng = torch.Generator(device=device)\n",
    "        sample_rng.manual_seed(42 + ddp_rank) # seed the number generator for reproducibility\n",
    "        while xgen.size(1) < max_length:\n",
    "            # forward the model to get the logits\n",
    "            with torch.no_grad():\n",
    "                logits, loss = model(xgen) # (B, T, vocab_size)\n",
    "                # take the logits at the last position\n",
    "                logits = logits[:, -1, :] # (B, vocab_size)\n",
    "                # get the probabilities\n",
    "                probs = F.softmax(logits, dim=-1)\n",
    "                # do top-k sampling of 50 (huggingface pipeline default)\n",
    "                # topk_probs here becomes (5, 50), topk_indices is (5, 50)\n",
    "                topk_probs, topk_indices = torch.topk(probs, 50, dim=-1)\n",
    "                # select a token from the top-k probabilities\n",
    "                # note: multinomial does not demand the input to sum to 1\n",
    "                ix = torch.multinomial(topk_probs, 1, generator=sample_rng) # (B, 1)\n",
    "                # gather the corresponding indices\n",
    "                xcol = torch.gather(topk_indices, -1, ix) # (B, 1)\n",
    "                # append to the sequence\n",
    "                xgen = torch.cat((xgen, xcol), dim=1) # (B, T+1)\n",
    "        # print the generated text\n",
    "        for i in range(num_return_sequences):\n",
    "            tokens = xgen[i, :max_length].tolist()\n",
    "            decoded = enc.decode(tokens)\n",
    "            print(f\"rank {ddp_rank} sample {i}: {decoded}\")\n",
    "    # [...]\n",
    "```\n",
    "\n",
    "This is essentially the exact same logic as we applied in `train_gpt2_1.py`.<br>\n",
    "The only slight difference is that we now generate multiple samples at once and use a seeded random number generator for reproducibility."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### HellaSwag Eval\n",
    "\n",
    "We can get more meaningful insights into the performance of our model by evaluating it not only on the validation set,<br>\n",
    "but also on what is called HellaSwag eval [\\[Zellers et al. 2019\\]](https://arxiv.org/abs/1905.07830).\n",
    "\n",
    "HellaSwag is a sentence completion dataset that requires a model to use its gained world knowledge and reasoning to complete sentences.\n",
    "\n",
    "![](./images/hellaswag_question.png)<br>\n",
    "Source: [\\[Zellers et al. 2019\\]](https://arxiv.org/abs/1905.07830)\n",
    "\n",
    "\n",
    "This eval was actually used for [GPT-3](https://arxiv.org/abs/2005.14165) as well. And it's actually quite good, because it provides us with so-called 'early signal' on the model's performance.<br>\n",
    "Even from early on in training, we can see how well the model is doing on this task and how it is improving over time.\n",
    "\n",
    "While this all sounds nice and good, and it seems reasonable that this eval can be used to test the model's performance and generalization capabilities, it is not yet clear how to implement this in our training script.<br>\n",
    "How can we make our text generation model answer multiple-choice questions?\n",
    "\n",
    "We can not assume that our still quite small model grasped the notion of answering multiple-choice questions.<br>\n",
    "Instead, we can provide the question-answer pairs, e.g. four times the same question respectively concatenated with one answer candidate,<br>\n",
    "in the format of a batch of question-answer sequences.<br>\n",
    "We pad the smaller sequences with a padding token to make them all the same length, that being the length of the longest sequence in the batch.<br>\n",
    "Only one of the sequences in the batch will contain the correct answer to the question.\n",
    "\n",
    "> We will say that the sequence with the highest average token probability is the one that contains the answer as predicted by the model.<br>\n",
    "> The intuitiion behind this is that the language model deems this sequence to be the overall most likely to follow the question.\n",
    "\n",
    "Note that this setup is both specific to the model and the HellaSwag eval. Other evals may require different setups.<br>\n",
    "For example, in our setup we don't let the model see all the answer candidates at once, but only one at a time.<br>\n",
    "This can be adapted depending on the requirements we have for the model, but it's a good starting point here.\n",
    "\n",
    "An implementation of this very approach to evaluating a model with `HellaSwag` can be found in the `hellaswag.py` script.<br>\n",
    "(The `evaluate` function is a good entry point for understanding the implementation.)\n",
    "\n",
    "If this `hellaswag.py` script is run for `gpt2 (124M)`, it will evaluate the model with a score of `0.2955`.<br>\n",
    "For reference, random chance is `0.25`, so `gpt2` is doing just marginally better.\n",
    "\n",
    "A real jump can be seen when evaluating `gpt2-xl (1558M)`, which scores `0.4893`.<br>\n",
    "This is a significant improvement over the `gpt2` model, but still not perfect.\n",
    "\n",
    "**With our setup, our goal is to beat the `gpt2 (124M)` model benchmark.**\n",
    "\n",
    "To incorporate this eval, we will have to adapt our `train_gpt2_5.py` script.<br>\n",
    "This can be done within the main training loop like so:\n",
    "\n",
    "```python\n",
    "# once in a while, evaluate the hellaswag dataset\n",
    "if (step % 250 == 0 or last_step) and (not use_compile):\n",
    "    model.eval()\n",
    "    num_correct_norm = 0\n",
    "    num_total = 0\n",
    "\n",
    "    for i, example in enumerate(iterate_examples(\"val\")):\n",
    "        # Only process examples where i % ddep_world_size == ddp_rank\n",
    "        if i % ddp_world_size != ddp_rank:\n",
    "            continue\n",
    "        # Render the example into tokens and labels\n",
    "        _, tokens, mask, label = render_example(example)\n",
    "        tokens = tokens.to(device)\n",
    "        mask = mask.to(device)\n",
    "        # Get the logits\n",
    "        with torch.no_grad():\n",
    "            with torch.autocast(device_type=device, dtype=torch.bfloat16):\n",
    "                logits, _ = model(tokens, mask)\n",
    "            pred_norm = get_most_likely_row(tokens, mask, logits)\n",
    "        num_total += 1\n",
    "        num_correct_norm += int(pred_norm == label)\n",
    "    if ddp:\n",
    "        num_total = torch.tensor(num_total, dtype=torch.long, device=device)\n",
    "        num_correct_norm = torch.tensor(num_correct_norm, dtype=torch.long, device=device)\n",
    "        dist.all_reduce(num_total, op=dist.ReduceOp.SUM)\n",
    "        dist.all_reduce(num_correct_norm, op=dist.ReduceOp.SUM)\n",
    "        num_total = num_total.item()\n",
    "        num_correct_norm = num_correct_norm.item()\n",
    "    acc_norm = num_correct_norm / num_total\n",
    "    if master_process:\n",
    "        print(f\"HellaSwag acc_norm: {num_correct_norm}/{num_total}={acc_norm:.6f}\")\n",
    "        with open(log_file, \"a\") as f:\n",
    "            f.write(f\"{step} hellaswag {acc_norm:.6f}\\n\")\n",
    "```\n",
    "\n",
    "We integrate the HellaSwag evaluation into the main training loop of `train_gpt2_5.py` and have the eval run every $250$ steps.<br>\n",
    "It injects eval batches into the model and determines the model's predicted most likely sequence against the correct label.<br>\n",
    "All of this is also optmized for distributed data parallelism, so we can effectively run synchronized evaluations across multiple GPUs.<br>\n",
    "For tracking model performance, the results are logged over time in `log.txt`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Training Progress\n",
    "\n",
    "With Loss calculation and evaluation in place, once training is done, we can visualize the training progress.<br>\n",
    "This can be done for example with the code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "sz = \"124M\"\n",
    "\n",
    "loss_baseline = {\n",
    "    \"124M\": 3.2924,\n",
    "}[sz]\n",
    "\n",
    "# HellaSwag for GPT-2\n",
    "hella2_baseline = {\n",
    "    \"124M\": 0.294463,\n",
    "    \"350M\": 0.375224,\n",
    "    \"774M\": 0.431986,\n",
    "    \"1558M\": 0.488946,\n",
    "}[sz]\n",
    "\n",
    "# EleutherAI for GPT-3\n",
    "hella3_baseline = {\n",
    "    \"124M\": 0.337,\n",
    "    \"350M\": 0.436,\n",
    "    \"774M\": 0.510,\n",
    "    \"1558M\": 0.547,\n",
    "}[sz]\n",
    "\n",
    "# load the log file\n",
    "with open(\"log124M/log.txt\", 'r') as f:\n",
    "    lines = f.readlines()\n",
    "\n",
    "# parse the individual lines, group by stream (train, val, hella)\n",
    "streams = {}\n",
    "for line in lines:\n",
    "    step, stream, val = line.strip().split()\n",
    "    if stream not in streams:\n",
    "        streams[stream] = []\n",
    "    streams[stream][int(step)] = float(val)\n",
    "\n",
    "# convert each stream from {step: val} to {steps[], vals[]}\n",
    "# so it's easier for plotting\n",
    "streams_xy = {}\n",
    "for k, v in streams.items():\n",
    "    # get all (step, val) pairs, sort by step\n",
    "    xy = sorted(list(v.items()))\n",
    "    # unpack the list of tuples into tuple of lists\n",
    "    streams_xy[k] = list(zip(*xy))\n",
    "\n",
    "# Create Figure\n",
    "plt.figure(figsize=(16, 6))\n",
    "\n",
    "# Panel 1: losses - both train and val\n",
    "plt.subplot(1, 2, 1)\n",
    "xs, ys = streams_xy[\"train\"] # train losses\n",
    "plt.plot(xs, ys, label=f\"NanoGPT ({sz}) - Train Loss\")\n",
    "print(\"Min Train Loss:\", min(ys))\n",
    "xs, ys = streams_xy[\"val\"] # val losses\n",
    "plt.plot(xs, ys, label=f\"NanoGPT ({sz}) - Val Loss\")\n",
    "\n",
    "# Horizontal line at GPT-2 baseline\n",
    "if loss_baseline is not None:\n",
    "    plt.axhline(y=loss_baseline, color='r', linestyle='--', label=f\"OpenAI GPT-2 ({sz}) Loss Baseline\")\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.yscale(\"log\")\n",
    "plt.ylim(0.0, 4.0)\n",
    "plt.legend()\n",
    "plt.title(\"Loss\")\n",
    "print(\"Min Validation Loss:\", min(ys))\n",
    "\n",
    "# Panel 2: HellaSwag Eval\n",
    "plt.subplot(1, 2, 2)\n",
    "xs, ys = streams_xy[\"hella\"] # HellaSwag scores\n",
    "ys = np.array(ys)\n",
    "plt.plot(xs, ys, label=f\"NanoGPT ({sz}) - HellaSwag\")\n",
    "# Horizontal line at GPT-2 baseline\n",
    "if hella2_baseline is not None:\n",
    "    plt.axhline(y=hella2_baseline, color='r', linestyle='--', label=f\"OpenAI GPT-2 ({sz}) HellaSwag Baseline\")\n",
    "if hella3_baseline is not None:\n",
    "    plt.axhline(y=hella3_baseline, color='g', linestyle='--', label=f\"OpenAI GPT-3 ({sz}) HellaSwag Baseline\")\n",
    "plt.xlabel(\"Steps\")\n",
    "plt.ylabel(\"Accuracy\")\n",
    "plt.legend()\n",
    "plt.title(\"HellaSwag Eval Accuracy\")\n",
    "print(\"Max HellaSwag:\", max(ys))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For reference, this is what it could look like:\n",
    "\n",
    "![](./images/plot_loss_hellaswag.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that if run long enough, the validation loss of our `train_gpt2_5.py` script on the `FneWeb EDU` dataset<br>\n",
    "will decrease over time and go significantly below the `GPT-2` validation loss benchmark.\n",
    "\n",
    "Also, the HellaSwag eval accuracy will increase over time, and also surpass the `GPT-2` model benchmark, nearly reaching `GPT-3` levels.<br>\n",
    "This is curious, because we train on a much smaller dataset than the `GPT-2` model was trained on.<br>\n",
    "But, for example, it could be possible that the original dataset was wider in scope and therefore to some extent more noisy.<br>\n",
    "Also, `FineWeb EDU` is all english and doesn't contain too much math or code.\n",
    "\n",
    "Of course, this is kind of comparing apples with oranges, because we don't run the same dataset through the same model.<br>\n",
    "But it's a good indicator nonetheless, because we built things to be close to the original at least."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opportunities for Optimization and Enhancement\n",
    "\n",
    "In future adaptations, one could improve the `DataLoaderLite` to introduce more permutation in the assembly of GPU-wise data subsets.<br>\n",
    "This could inform the model training subprocesses better/more evenly about the full dataset and improve generalization.\n",
    "\n",
    "Also, it turns out that the original `max_lr` learning rate is quite conservative.<br>\n",
    "We can actually increase it up to even `2e-4` for faster training.\n",
    "\n",
    "If you want to get closer to `GPT-3` performance, we could also increase the model size and<br>\n",
    "double the context size to `2048` and half the batch size to `32` as layed out in the [GPT-3 paper \\[Brown et al. 2020\\]](https://arxiv.org/abs/2005.14165).\n",
    "\n",
    "You can also go ahead and try additional methods of evaluation like the [Eleuther Evaluation Harness](https://github.com/EleutherAI/lm-evaluation-harness) or train on another dataset like [Pile](https://pile.eleuther.ai/).\n",
    "\n",
    "There's also an implementation of our version of GPT hiding inside [LLM.c](https://github.com/karpathy/llm.c) which was also made by Andrej.<br>\n",
    "It's essentially the same, but noticably faster and more memory efficient.\n",
    "\n",
    "<br>\n",
    "<br>\n",
    "<br>\n",
    "\n",
    "---\n",
    "\n",
    "<center>If you run <code>train_gpt2-5.py</code> for long enough now, you will get a model that is in some ways as good as OpenAI's GPT-2 model, if not better.<br>\n",
    "All you need to do is run <code>torchrun --standalone --nproc_per_node=[GPU COUNT] train_gpt2_5.py</code> and specify the number of GPUs you have available.<br>\n",
    "<b>This script (combined with the the right data) would be state-of-the-art in 2018.</b><br>\n",
    "<b>That's insane!</b></center>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center>Notebook by <a href=\"https://github.com/mk2112\" target=\"_blank\">mk2112</a>.</center>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}